⚡ electrical engineering

$\partial$ CBDs: Differentiable Causal Block Diagrams

The paper introduces $\partial$ CBDs (Differentiable Causal Block Diagrams), a unifying modeling formalism that integrates the modular composition of causal block diagrams, the formal correctness of assume-guarantee contracts, and the gradient-based optimization capabilities of differentiable programming to create a scalable and verifiable framework for cyber-physical systems.

Original authors: Thomas Beckers, Ján Drgoňa, Truong X. Nghiem

Published 2026-02-10

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Thomas Beckers, Ján Drgoňa, Truong X. Nghiem

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are building a high-tech, self-driving delivery robot. To make this robot work, you need three different "experts" to work together:

The Architect (Modeling): This person draws the blueprints. They decide how the wheels connect to the motor, how the sensors talk to the brain, and how the battery powers everything. They use "Block Diagrams"—basically a Lego-like instruction manual where every part has a specific job.
The Teacher (Learning): This person watches the robot fail and helps it improve. If the robot bumps into a curb, the teacher says, "Adjust your steering next time!" This is "Machine Learning"—learning from mistakes to get better.
The Safety Inspector (Verification): This person is the strict rule-follower. They don't care if the robot is fast or smart; they only care if it’s safe. They demand proof: "Show me that this robot will never exceed 5 mph near a human."

The Problem:
In the real world, these three experts rarely speak the same language. The Architect’s blueprints are too rigid for the Teacher to change. The Teacher is great at making the robot smart, but they often "cheat" or take risks that make the Safety Inspector panic. And the Safety Inspector’s rules are usually so strict that they prevent the robot from ever actually learning anything new.

The Solution: $\partial$ CBDs (The "Smart Blueprint")

The researchers created something called $\partial$ CBDs (Differentiable Causal Block Diagrams). Think of this as a "Living, Breathing Blueprint."

Instead of a static paper drawing, $\partial$ CBDs is a digital blueprint that is "squishy" and "smart." Here is how it fixes the three-way tension:

1. The "Squishy" Blueprint (Differentiability)

In old blueprints, if you wanted to change a part, you had to redraw the whole thing. In $\partial$ CBDs, the connections are "differentiable."

Analogy: Imagine if your Lego instructions weren't made of hard plastic, but of modeling clay. If the "Teacher" realizes the robot needs a slightly wider base to stay stable, they don't have to rebuild the robot from scratch; they can just "nudge" the clay, and the change flows through the entire structure automatically. This allows the robot to learn through math (gradients) without breaking the design.

2. The "Smart Contracts" (Assume-Guarantee)

To keep the Safety Inspector happy, the researchers added "Contracts" to every single block.

Analogy: Think of this like a legal contract between coworkers. The Motor Block says: "I assume you will give me 12 volts, and in return, I guarantee I will spin at 500 RPM."
Because these contracts are part of the blueprint, if the "Teacher" tries to change the motor to something that requires 24 volts, the blueprint immediately "red-flags" it because it breaks the contract with the battery.

3. The "Safety Scorecard" (Residuals)

This is the secret sauce. Usually, safety rules are "Yes/No"—you either pass or you fail. But $\partial$ CBDs turns safety into a scorecard.

Analogy: Instead of a teacher saying "You failed the test," they give you a score of 85%. This "score" (called a residual) tells the "Teacher" exactly how much they missed the safety mark by.
Because this score is a number, the "Teacher" can use it to guide the learning. The robot thinks: "I want to go fast to deliver the pizza, but my 'Safety Score' is dropping. I need to slow down just enough to bring my score back up to 100%."

Why does this matter?

By combining these three things, we can build machines—like autonomous cars, surgical robots, or power grids—that are:

Modular: Built like Legos (easy to understand).
Smart: Can learn from data (can adapt).
Safe: Have mathematical "contracts" that ensure they won't go rogue (can be trusted).

In short, $\partial$ CBDs allows us to build robots that learn how to be smart without forgetting how to be safe.

Technical Summary: $\partial$ CBDs: Differentiable Causal Block Diagrams

1. Problem Statement

Modern Cyber-Physical Systems (CPS) are increasingly complex, integrating physical dynamics, computational logic, and machine learning. This complexity creates a "three-way tension" between three critical engineering requirements:

Compositionality: The ability to manage structural complexity by connecting modular components.
Learnability: The ability to adapt models and controllers using data-driven optimization (e.g., gradient descent).
Verifiability: The ability to ensure safety and correctness through formal guarantees (e.g., stability, passivity).

Existing methodologies typically address these in isolation. Causal Block Diagrams (CBDs) are excellent for composition but are not natively differentiable for learning. Differentiable Programming (DP) enables end-to-end optimization but lacks formal correctness guarantees. Contract-based verification provides safety proofs but is usually decoupled from the data-driven optimization process.

2. Methodology

The authors propose $\partial$ CBDs (Differentiable Causal Block Diagrams), a unifying formalism that integrates these three perspectives into a single, tractable pipeline. The framework is structured across five layers: structural, semantic, contract, differentiable, and optimization.

Key Methodological Components:

Block-with-Contract Formalism: Each block is defined by its inputs ( $U$ ), internal states ( $X$ ), outputs ( $Y$ ), time semantics ( $T$ ), state transition functions ( $F$ ), output functions ( $g$ ), and a set of contracts ( $C$ ).
Dual-Layer Contracts:
- Assume–Guarantee (A–G) Contracts: Provide normative, system-wide specifications for modular correctness reasoning (e.g., "If input $A$ is provided, output $G$ is guaranteed").
- Residual-Based Contracts: Provide differentiable, trajectory-level certificates. These are quantitative functions ( $C_{res} \leq 0$ ) that can be evaluated during a simulation and used as penalty terms in an optimization objective.
Differentiability via AD: The framework ensures that CBDs can be reduced to Directed Acyclic Graphs (DAGs) compatible with Automatic Differentiation (AD). This is achieved through:
- Rate Lifting: Synchronizing different sampling periods.
- Loop Unrolling: Converting feedback loops into finite-horizon serial compositions.
- Sensitivity Propagation: Using Jacobian-vector products (JVP) and vector-Jacobian products (VJP) to propagate gradients through ODE/DAE solvers, neural networks, and optimization layers.
Unified Optimization Problem: The framework formulates a general constrained optimization problem where the objective function $J$ (performance) is minimized subject to the system's execution semantics and the differentiable contract residuals.

3. Key Contributions

A New Formalism: A differentiable extension of CBDs that preserves the structural clarity of traditional modeling while enabling gradient-based optimization.
Differentiable Certificates: The introduction of residual-based contracts that turn formal specifications (like Lyapunov stability) into optimization-aware constraints.
Reduction Algorithm: A principled method to transform complex, multi-rate, feedback-driven CBDs into AD-executable computational graphs.

4. Results and Case Studies

The paper validates the framework through three distinct examples:

Example 1: Scalar Feedback Gain Tuning: Demonstrates stability-certified tuning. By using a residual contract for input-to-state stability (ISS), the system successfully tunes a proportional gain that satisfies stability margins even in the presence of bounded disturbances.
Example 2: Joint Neural Policy and Lyapunov Learning: Reproduces Differentiable Predictive Control (DPC). The framework jointly learns a neural network controller and a neural Lyapunov function (using an Input-Convex Neural Network) to ensure the stability of a nonlinear Van der Pol oscillator.
Example 3: Deep Koopman Operator Learning: Demonstrates "stable-by-construction" system identification. The framework learns a linear latent representation of nonlinear dynamics while enforcing a contract on the spectral radius of the Koopman operator, ensuring the learned model is contractive.

5. Significance

$\partial$ CBDs bridge the gap between control theory/formal methods and machine learning. By making formal contracts "visible" to gradient-based optimizers, the framework allows engineers to design systems that are not just high-performing, but also provably safe and physically consistent. This has profound implications for the development of verifiable agentic AI, autonomous vehicles, and complex industrial robotics, where safety-critical guarantees must coexist with adaptive, data-driven intelligence.

The Solution: ∂\partial∂CBDs (The "Smart Blueprint")