Merge pull request #276 from marvin-hansen/main

feat(deep_causality): Unified Evidence and PropagatingEffect into a single type.

Author: marvin-hansen

Cargo.lock

@@ -7,7 +7,7 @@ module(name = "deep_causality")
 bazel_dep(name = "aspect_bazel_lib", version = "2.16.0")
 bazel_dep(name = "bazel_skylib", version = "1.7.1")
 bazel_dep(name = "platforms", version = "0.0.11")
-bazel_dep(name = "rules_rust", version = "0.62.0")
+bazel_dep(name = "rules_rust", version = "0.63.0")
 
 ###############################################################################
 # Rust toolchain

MODULE.bazel

@@ -16,7 +16,7 @@ fn small_causality_collection_benchmark(criterion: &mut Criterion) {
     // The `_data` is no longer needed as we pass a single evidence object.
     let (coll, _data) = utils_collection::get_small_collection_and_data();
     // All propagation methods now take a single `&Evidence`.
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
 
     criterion.bench_function("small_causality_collection_propagation", |bencher| {
         bencher.iter(|| coll.evaluate_deterministic_propagation(&evidence).unwrap())
@@ -25,7 +25,7 @@ fn small_causality_collection_benchmark(criterion: &mut Criterion) {
 
 fn medium_causality_collection_benchmark(criterion: &mut Criterion) {
     let (coll, _data) = utils_collection::get_medium_collection_and_data();
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
 
     criterion.bench_function("medium_causality_collection_propagation", |bencher| {
         bencher.iter(|| coll.evaluate_deterministic_propagation(&evidence).unwrap())
@@ -34,7 +34,7 @@ fn medium_causality_collection_benchmark(criterion: &mut Criterion) {
 
 fn large_causality_collection_benchmark(criterion: &mut Criterion) {
     let (coll, _data) = utils_collection::get_large_collection_and_data();
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
 
     criterion.bench_function("large_causality_collection_propagation", |bencher| {
         bencher.iter(|| coll.evaluate_deterministic_propagation(&evidence).unwrap())

deep_causality/benches/benchmarks/bench_collection.rs

@@ -15,7 +15,7 @@ const LARGE: usize = 10_000;
 
 fn small_linear_graph_benchmark(criterion: &mut Criterion) {
     let g = utils_linear_graph::build_linear_graph(SMALL);
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
     let root_index = g.get_root_index().unwrap();
 
     criterion.bench_function(
@@ -52,7 +52,7 @@ fn small_linear_graph_benchmark(criterion: &mut Criterion) {
 
 fn medium_linear_graph_benchmark(criterion: &mut Criterion) {
     let g = utils_linear_graph::build_linear_graph(MEDIUM);
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
     let root_index = g.get_root_index().unwrap();
 
     criterion.bench_function(
@@ -89,7 +89,7 @@ fn medium_linear_graph_benchmark(criterion: &mut Criterion) {
 
 fn large_linear_graph_benchmark(criterion: &mut Criterion) {
     let g = utils_linear_graph::build_linear_graph(LARGE);
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
     let root_index = g.get_root_index().unwrap();
 
     criterion.bench_function(

deep_causality/benches/benchmarks/bench_graph.rs

@@ -5,7 +5,7 @@
 
 use criterion::{Criterion, criterion_group};
 
-use deep_causality::{Causable, Evidence};
+use deep_causality::{Causable, PropagatingEffect};
 
 use crate::benchmarks::utils_map;
 
@@ -20,7 +20,7 @@ fn small_causality_map_benchmark(criterion: &mut Criterion) {
             // Iterate over the map and evaluate each causaloid with its specific data.
             for (key, cause) in &map {
                 let value = data.get(key).expect("Data missing for key");
-                let evidence = Evidence::Numerical(*value);
+                let evidence = PropagatingEffect::Numerical(*value);
                 cause.evaluate(&evidence).unwrap();
             }
         })
@@ -33,7 +33,7 @@ fn medium_causality_map_benchmark(criterion: &mut Criterion) {
         bencher.iter(|| {
             for (key, cause) in &map {
                 let value = data.get(key).expect("Data missing for key");
-                let evidence = Evidence::Numerical(*value);
+                let evidence = PropagatingEffect::Numerical(*value);
                 cause.evaluate(&evidence).unwrap();
             }
         })
@@ -46,7 +46,7 @@ fn large_causality_map_benchmark(criterion: &mut Criterion) {
         bencher.iter(|| {
             for (key, cause) in &map {
                 let value = data.get(key).expect("Data missing for key");
-                let evidence = Evidence::Numerical(*value);
+                let evidence = PropagatingEffect::Numerical(*value);
                 cause.evaluate(&evidence).unwrap();
             }
         })

deep_causality/benches/benchmarks/bench_map.rs

@@ -12,7 +12,7 @@ use crate::benchmarks::utils_linear_graph;
 fn small_multi_layer_graph_benchmark(criterion: &mut Criterion) {
     // The data array is no longer used; we use a single Evidence object.
     let (g, _data) = utils_linear_graph::get_small_multi_cause_graph_and_data();
-    let evidence = Evidence::Numerical(0.99);
+    let evidence = PropagatingEffect::Numerical(0.99);
 
     let root_index = g.get_root_index().expect("Graph has no root");
     criterion.bench_function("small_multi_layer_graph_evaluate_from_root", |bencher| {

deep_causality/benches/benchmarks/bench_multi_cause_graph.rs

@@ -5,16 +5,16 @@
 
 use deep_causality::errors::CausalityError;
 use deep_causality::{
-    BaseCausaloid, Causaloid, Evidence, IdentificationValue, NumericalValue, PropagatingEffect,
+    BaseCausaloid, Causaloid, IdentificationValue, NumericalValue, PropagatingEffect,
 };
 
 pub fn get_test_causaloid() -> BaseCausaloid {
     let id: IdentificationValue = 1;
     let description = "tests whether data exceeds threshold of 0.55";
 
-    fn causal_fn(evidence: &Evidence) -> Result<PropagatingEffect, CausalityError> {
+    fn causal_fn(evidence: &PropagatingEffect) -> Result<PropagatingEffect, CausalityError> {
         let obs = match evidence {
-            Evidence::Numerical(val) => *val,
+            PropagatingEffect::Numerical(val) => *val,
             _ => return Err(CausalityError("Expected Numerical evidence.".into())),
         };
 

deep_causality/benches/benchmarks/utils_shared.rs

@@ -140,8 +140,6 @@ pub use crate::types::model_types::model::Model;
 pub use crate::types::model_types::observation::Observation;
 // Reasoning types
 pub use crate::types::reasoning_types::propagating_effect::PropagatingEffect;
-pub use crate::types::reasoning_types::reasoning_mode::ReasoningMode;
-pub use crate::types::reasoning_types::unified_evidence::Evidence;
 //
 //Symbolic types
 pub use crate::types::symbolic_types::symbolic_representation::SymbolicRepresentation;

deep_causality/src/lib.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::{Causable, CausalityError, Evidence, NumericalValue, PropagatingEffect};
+use crate::{Causable, CausalityError, NumericalValue, PropagatingEffect};
 
 /// Provides default implementations for reasoning over collections of `Causable` items.
 ///
@@ -42,16 +42,16 @@ where
     /// to `Deterministic(false)`, the chain evaluation stops and returns that effect.
     ///
     /// # Arguments
-    /// * `evidence` - A single `Evidence` object (e.g., a Map or Graph) that all causes will use.
+    /// * `effect` - A single `PropagatingEffect` object (e.g., a Map or Graph) that all causes will use.
     ///
     /// # Errors
     /// Returns a `CausalityError` if any cause in the chain produces a non-deterministic effect.
     fn evaluate_deterministic_propagation(
         &self,
-        evidence: &Evidence,
+        effect: &PropagatingEffect,
     ) -> Result<PropagatingEffect, CausalityError> {
         for cause in self.get_all_items() {
-            let effect = cause.evaluate(evidence)?;
+            let effect = cause.evaluate(effect)?;
 
             // This function enforces a strict deterministic contract.
             match effect {
@@ -83,18 +83,18 @@ where
     /// of 1.0 and `false` as 0.0.
     ///
     /// # Arguments
-    /// * `evidence` - A single `Evidence` object that all causes will use.
+    /// * `effect` - A single `PropagatingEffect` object that all causes will use.
     ///
     /// # Errors
     /// Returns a `CausalityError` if a `ContextualLink` is encountered.
     fn evaluate_probabilistic_propagation(
         &self,
-        evidence: &Evidence,
+        effect: &PropagatingEffect,
     ) -> Result<PropagatingEffect, CausalityError> {
         let mut cumulative_prob: NumericalValue = 1.0;
 
         for cause in self.get_all_items() {
-            let effect = cause.evaluate(evidence)?;
+            let effect = cause.evaluate(effect)?;
 
             match effect {
                 PropagatingEffect::Probabilistic(p) => {
@@ -117,6 +117,12 @@ where
                         "Encountered a ContextualLink in a probabilistic chain evaluation.".into(),
                     ));
                 }
+                _ => {
+                    // Other variants are not handled in this mode.
+                    return Err(CausalityError(format!(
+                        "evaluate_probabilistic_propagation encountered an unhandled effect: {effect:?}"
+                    )));
+                }
             }
         }
 
@@ -127,19 +133,19 @@ where
     /// probabilistic effects, aggregating them into a final effect.
     ///
     /// # Arguments
-    /// * `evidence` - A single `Evidence` object that all causes will use.
+    /// * `effect` - A single `PropagatingEffect` object that all causes will use.
     ///
     /// # Errors
     /// Returns a `CausalityError` if a `ContextualLink` is encountered.
     fn evaluate_mixed_propagation(
         &self,
-        evidence: &Evidence,
+        effect: &PropagatingEffect,
     ) -> Result<PropagatingEffect, CausalityError> {
         // The chain starts as deterministically true. It can transition to probabilistic.
         let mut aggregated_effect = PropagatingEffect::Deterministic(true);
 
         for cause in self.get_all_items() {
-            let current_effect = cause.evaluate(evidence)?;
+            let current_effect = cause.evaluate(effect)?;
 
             // Update the aggregated effect based on the current effect.
             aggregated_effect = match (aggregated_effect, current_effect) {

deep_causality/src/traits/causable/causable_reasoning.rs

@@ -2,8 +2,7 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-use crate::errors::CausalityError;
-use crate::{Evidence, Identifiable, PropagatingEffect};
+use crate::{CausalityError, Identifiable, PropagatingEffect};
 
 pub mod causable_reasoning;
 
@@ -13,7 +12,7 @@ pub mod causable_reasoning;
 /// for evaluation and state inspection, regardless of whether the element is a single
 /// causaloid, a collection, or a graph.
 pub trait Causable: Identifiable {
-    /// Evaluates the causal element against the provided runtime evidence.
+    /// Evaluates the causal element against the provided runtime effect.
     ///
     /// This is the primary method for executing the reasoning logic of a causal element.
     /// - For a `Singleton`, this typically involves executing its `CausalFn`.
@@ -22,13 +21,13 @@ pub trait Causable: Identifiable {
     ///
     /// # Arguments
     ///
-    /// * `evidence` - A reference to the `Evidence` flowing through the causal graph.
+    /// * `effect` - A reference to the `PropagatingEffect` flowing through the causal graph.
     ///
     /// # Returns
     ///
     /// A `Result` containing a `PropagatingEffect` on success, or a `CausalityError`
     /// if the evaluation fails.
-    fn evaluate(&self, evidence: &Evidence) -> Result<PropagatingEffect, CausalityError>;
+    fn evaluate(&self, effect: &PropagatingEffect) -> Result<PropagatingEffect, CausalityError>;
 
     /// Generates a human-readable explanation of the causaloid's current state.
     ///