Request for Comments (RFC): Integrating First-Class Uncertainty into DeepCausality via Uncertain<T> Semantics

[marvin-hansen]

Author: Marvin Hansen
Date: Fri, Aug. 29 2025
Status: Draft Proposal

---

Abstract

This RFC proposes a fundamental architectural enhancement to the Effect Propagation Process (EPP) reference implementation, DeepCausality: the integration of first-class uncertainty primitives inspired by the Microsoft Research paper, Uncertain<T> and its implementation in Swift by Mattt.

The current EPP is a deterministic meta-calculus that can encapsulate probabilistic logic (via ΠProb and Causaloids containing statistical models). This proposal shifts DeepCausality to a system where uncertainty is a native primitive, enabling causal reasoning over full probability distributions rather than single-point estimates.

This integration provides the precise mathematical language and engineering ergonomics necessary to formalize high-confidence decision-making, transforming the Causal State Machine (CSM) and the Effect Ethos into verifiable, risk-aware policy engines. This capability shatters current limitations in computational causality regarding the management of cascading uncertainty and high-confidence inference.

1. Motivation: The Limit of Encapsulation

The core axiom of the EPP, $E_2 = f(E_1)$, allows f to be a probabilistic function, and the PropagatingEffect has a ΠProb variant. However, two critical problems remain:

1. Cascading Uncertainty: When the probabilistic result of Causaloid A feeds into Causaloid B, the error and distribution spread are typically lost or approximated manually, leading to error compounding and "uncertainty bugs" (false positives/negatives), as demonstrated by Bornholt et al.
2. Brittle Decisions: The CSM relies on a boolean predicate derived from a single threshold (if (effect > X)). This treats a 95% likelihood with high variance identically to a 95% likelihood with low variance, making critical decisions unnecessarily brittle and opaque.

The Uncertain<T> concept solves these problems elegantly by making the distribution the fundamental value. The fact that the entire Swift implementation is compact (approx. 1,600 lines) and relies on standard functional programming concepts proves this is a high-leverage, low-friction integration.

2. Proposal: Integration of Uncertain<T> Semantics

We propose modifying DeepCausality’s core primitives to adopt Uncertain<T> semantics, specifically the sampling functions, lazy evaluation graph, and statistical conditional operators (Hypothesis Testing).

2.1. Core Type Modification: The PropagatingEffect (ΠE)

The current ΠProb variant should be generalized to carry a full distribution type.

Proposed Change to ΠE:

• Replace ΠProb = {Probabilistic(p) | p ∈ [0, 1]}
• Introduce ΠUncertain<T>: A type that wraps the distribution for a given payload type T.
• The PropagatingEffect will now carry a complete description of the probabilistic value, allowing downstream Causaloids to access the full distribution (mean, variance, mode, etc.).

2.2. Contextual Fabric Modification (C)

Contextoid payloads should natively support the new uncertain type.

Proposed Change to Contextoid Payload:

• Extend the payloadv union to optionally wrap its components in the Uncertain<T> semantic, especially for Datoid, Tempoid, and Spaceoid.
  • Example: A GPS coordinate (a Spaceoid) would hold an Uncertain<GeoCoordinate> that encapsulates the Rayleigh/Normal distribution model for GPS error, as detailed in the source code review.

2.3. Causaloid Functionality (fχ)

The core Causaloid function must seamlessly operate on these new uncertain types.

Proposed Change to Causaloid Logic:

1. Operator Overloading: Port the Uncertain<T> operator overloading (+, *, /, &&, ||, >) logic into Rust. This is critical for engineers to continue writing simple logic (speed = dist / time) while the system handles the complex convolution/sampling required for distribution propagation.
2. Memoization and Sampling Context: The EPP’s propagation engine (ΠEP P) must be updated to manage the SampleContext (the memoization map based on UUIDs). This ensures that if a single uncertain Contextoid (e.g., GPS reading) is referenced by multiple Causaloids in a single reasoning cycle, they all draw the same random sample, maintaining statistical consistency (a key feature of Uncertain<T>'s internal graph).

3. Impact and Unprecedented Payoff

Integrating Uncertain<T> realizes several promised EPP capabilities with unprecedented rigor:

EPP Component	Old Behavior	New Uncertain<T> Behavior	Payoff / Result
Causaloid Logic	Manual error propagation; brittle thresholds.	Seamless distribution arithmetic via operator overloading.	Correctness & Ergonomics: Simplifies causal model authoring and eliminates error compounding bugs.
Causal State Machine (CSM)	Predicate is boolean (if (P) is True).	Predicate is statistical (if P.probability(exceeds: α)).	Risk-Aware Decision: Decisions are now based on explicit confidence thresholds ($\alpha$), not arbitrary cutoffs.
Effect Ethos / Teloid	Norms are brittle logical constraints.	Norms become formal risk policies (e.g., Compliance-as-Code).	Verifiable Safety: Provides the mechanism to formally test and certify that actions comply with a defined tolerance for risk (e.g., $99.99%$ safety).
Dynamic Context	Context holds a simple noisy value.	Context holds the full distribution and its meta-data.	Dynamic Transparency: All causal reasoning is rooted in a full representation of the environment’s measured uncertainty.
Causal Emergence	Triggered by fixed rules (dangerous).	Triggered by high-confidence statistical tests (safe).	Principled Emergence: The capacity to self-modify is gated by a rigorous statistical check, transforming emergence into a controlled adaptation mechanism.

4. Implementation and Discussion

Proposed Immediate Next Steps (RFC Stage):

1. Feasibility Study & Core Port: Conduct a formal PoC project to port the core Uncertain<T> struct, operators, and the necessary underlying statistical distributions (Normal, Rayleigh) to Rust, ensuring seamless integration with existing DeepCausality structures (especially the Contextoid generics).
2. PropagatingEffect and CausalFn Refactoring: Define the new ΠUncertain<T> type and update the CausalFn traits to accept and return these uncertain types.
3. CSM Update: Implement the evaluateHypothesis logic into the CSM activation mechanism, making high-confidence conditional logic the standard for actionable intelligence.

This is a critical architectural decision that requires consensus. The proposed change fundamentally elevates the EPP’s core capabilities from a relatively modest contribtuion to one of the most advanced computational framework for hybrid, contextual, dynamic, and verifiably safe causality.

5. Further Reading

nshipster
https://nshipster.com/uncertainty
https://github.com/mattt/Uncertain

microsoft research:
https://www.microsoft.com/en-us/research/publication/uncertaint-a-first-order-type-for-uncertain-data-2
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/asplos077-bornholtA.pdf
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/uncertaint-asplos-2014-slides.pdf

We invite feedback and discussion on this proposal.

[marvin-hansen]

Proposed new crate for implementation of the core Uncertain Type. While there are 2 existing crates, none of them aligns with the core requirements of performance and flexibility i.e. replacable samplers.

Progress is tracked in issue: #299