🔢 mathematics

Flow-Through Tensors: A Unified Computational Graph Architecture for Multi-Layer Transportation Network Optimization

This paper introduces Flow-Through Tensors (FTT), a unified computational graph architecture that integrates diverse transportation modeling methodologies into a single mathematical framework to enable gradient-based optimization, real-time control, and efficient multi-layer network analysis.

Original authors: Xuesong Zhou, Taehooie Kim, Mostafa Ameli, Henan Zhu, Yudai Honma, Ram M. Pendyala

Published 2026-07-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xuesong Zhou, Taehooie Kim, Mostafa Ameli, Henan Zhu, Yudai Honma, Ram M. Pendyala

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 a massive, bustling city where millions of people are trying to get from their homes to their jobs, schools, and shops. Right now, trying to manage this traffic is like trying to conduct an orchestra where every musician is reading from a different sheet of music, using a different instrument, and playing at a different speed. Some musicians are trying to predict the music (forecasting), others are trying to control the tempo (traffic lights), and others are just trying to figure out the best route (navigation). They rarely talk to each other, leading to chaos and traffic jams.

This paper introduces a new "universal sheet music" called Flow-Through Tensors (FTT). Think of it as a single, unified computer language that allows all these different traffic management tools to finally speak to one another.

Here is how the paper breaks down this idea using simple analogies:

1. The Problem: Too Many Separate Tools

Currently, traffic experts use different tools for different jobs:

Predictors look at cameras and sensors to guess where traffic will be.
Controllers adjust traffic lights or manage autonomous cars.
Planners calculate the best routes for everyone to take.
Behaviorists study why people choose to drive, take the bus, or walk.

The problem is that these tools don't connect. A prediction tool doesn't "know" what the controller is doing, and the planner doesn't see the real-time data. It's like a chef trying to cook a meal while the farmer, the truck driver, and the grocery store manager are all shouting instructions that don't match.

2. The Solution: The "Flow-Through Tensor" (The Universal Translator)

The authors propose a new architecture called Flow-Through Tensors. Imagine a giant, multi-layered digital Lego set.

The Layers: Instead of separate tools, everything is built into one structure. One layer represents where people want to go (Origin-Destination), the next layer represents the specific paths they take, and the final layer represents the actual roads and how crowded they are.
The Flow: Just like water flowing through pipes, traffic data flows through these layers. If you change the "Origin" (where people start), the math automatically updates the "Paths" and the "Road Congestion" instantly.
The Tensor: In math, a "tensor" is just a fancy way of organizing data in multiple dimensions (like a cube of numbers instead of a flat list). This allows the system to handle not just where people are going, but when they are going, who they are, and what they are driving, all at the same time.

3. How It Works: The "Backpropagation" Magic

The paper explains that this system uses a technique borrowed from Artificial Intelligence called automatic differentiation (or backpropagation).

The Analogy: Imagine you are trying to balance a stack of blocks. If the stack tips over, you need to know exactly which block to move to fix it.
The Application: In this traffic system, if the traffic gets too heavy, the computer doesn't just guess. It uses "gradients" (mathematical slopes) to trace the problem backward. It can say, "If we change the route for just 5% of the people leaving at 8:00 AM, the traffic jam at 8:15 AM disappears." It calculates the perfect adjustment instantly, rather than trying random changes.

4. Solving the "Chicken and Egg" Problem

Traffic is a cycle: People choose routes based on traffic, but traffic is caused by the routes people choose. This is a "chicken and egg" problem that is hard to solve.

The Paper's Fix: The authors use a method called ADMM (Alternating Direction Method of Multipliers).
The Analogy: Imagine two teams trying to agree on a schedule. Team A (Drivers) says, "I want to leave at 8:00." Team B (Roads) says, "That's too crowded; leave at 8:15." Instead of arguing forever, they use a "split" method. They agree on a compromise, check if it works, and then adjust slightly. They keep swapping notes until they find a perfect balance where everyone is happy and the roads aren't clogged. This allows the system to handle complex interactions between different types of traffic (like buses vs. cars) without crashing.

5. Real-World Results: Faster and Smarter

The paper doesn't just talk theory; it shows that this system works.

Speed: They tested this on a large network (like a whole city). Traditional methods took hours or even days to calculate the best routes. The new Tensor system did it in minutes or seconds.
Accuracy: It found solutions that were much closer to the "perfect" traffic flow than older methods.
Scalability: Because it uses modern computer chips (GPUs) designed for video games and AI, it can handle huge amounts of data without slowing down.

Summary

In short, this paper presents a new "operating system" for traffic. Instead of having separate apps for predicting, planning, and controlling traffic, it builds one giant, interconnected model. This model acts like a super-smart conductor, instantly adjusting the flow of traffic across the entire city to prevent jams, save time, and make the whole transportation network run like a well-oiled machine. It bridges the gap between theoretical math and the messy reality of real-world traffic.

Technical Summary: Flow-Through Tensors (FTT)

Problem Statement

Modern transportation network modeling faces a fragmentation challenge. Current methodologies—ranging from sensor-based forecasting and reinforcement learning (RL) to classical dynamic traffic assignment (DTA) and activity-based demand modeling—have traditionally evolved in isolation. While individual approaches offer specific strengths (e.g., high prediction accuracy in deep learning or solid theoretical foundations in user equilibrium), they lack a unified structure to handle the integration of multi-layer factors (OD matrices, path assignments, link flows) and multi-modal complexities.

Existing solvers (e.g., CPLEX, Gurobi) struggle with high-dimensional scalability and non-linear or stochastic elements inherent in real-world networks. Furthermore, traditional computational graphs (CG) in transportation have often been applied to specific, isolated tasks like discrete choice calibration or OD estimation, lacking a general framework that connects demand, supply, and physical constraints across multiple modeling layers. The core problem is the absence of a unified, differentiable architecture that can simultaneously handle gradient-based optimization, physical network constraints, and diverse data streams for real-time control and equilibrium analysis.

Methodology

The paper introduces Flow-Through Tensors (FTT), a unified computational graph architecture that represents transportation networks as interconnected tensors. The methodology bridges traditional transportation modeling with modern differentiable programming.

1. Tensor-Based Formulation

The FTT framework models the network using a layered structure connecting Origin-Destination (OD) flows, path flows, and link flows.

Variables: The framework defines scalars, vectors, and tensors for OD flows ( $f_{OD}$ ), path flows ( $f_P$ ), link flows ( $f_L$ ), and their corresponding travel times ( $t_{OD}, t_P, t_L$ ).
Mapping Matrices: Two key incidence matrices facilitate flow propagation:
- $B_{OD,P}$ (OD-to-Path): Represents route choice probabilities (dynamic, based on User Equilibrium or System Optimum).
- $A_{P,L}$ (Path-to-Link): Represents the physical incidence of paths on links.
Forward and Backward Propagation: The system operates as a composite function:
- Forward: $f_{OD} \to f_P \to f_L \to t_L$ (via performance functions like BPR).
- Backward: $t_L \to t_P \to t_{OD}$ (aggregating link times to path and OD times).
Differentiability: By embedding these mappings into a computational graph, the framework enables automatic differentiation. This allows for the explicit computation of gradients (e.g., $\frac{\partial t_{OD}}{\partial f_{OD}}$ ) via the chain rule, facilitating gradient-based optimization across previously disconnected modeling elements.

2. Multi-Dimensional Scheduling and Rotation

To address the inefficiencies of static, single-period equilibrium (captured by the Price of Anarchy), the paper proposes a multi-dimensional tensor representation.

Dimensions: The tensors encode attributes beyond simple time and space, including user classes, vehicle types, trip chains, and day-of-week effects.
Rotation Mechanism: A binary rotation tensor ( $R$ ) is introduced to coordinate user groups across time periods (e.g., days). This mechanism allows subsets of users to alternate between System Optimal (SO) and User Equilibrium (UE) assignments. The paper demonstrates via a Pigou network example that this rotation strategy yields Pareto improvements, reducing overall system cost and travel times compared to pure UE.

3. Modular Integration via ADMM

To handle complex, coupled constraints (e.g., passenger-vehicle capacity matching) and integrate diverse modules (e.g., ML-based OD estimation and physics-based flow assignment), the framework employs the Alternating Direction Method of Multipliers (ADMM).

Decomposition: The system is split into blocks (e.g., Passenger Block and Vehicle Block), each with its own objective function and variables.
Coupling: Constraints are enforced through shared variables (e.g., link flows) using Lagrangian multipliers. This allows modules to optimize independently while maintaining physical consistency (e.g., ensuring passenger flows do not exceed vehicle capacities).
Scalability: This decomposition supports parallel computation and modular integration of Machine Learning (ML) models with physics-informed constraints.

Key Contributions

Unified Mathematical Structure: The paper establishes a consistent tensor-based computational graph that connects OD flows, path probabilities, and link travel times. This structure enables gradient-based optimization across previously separate modeling elements (demand, assignment, and performance).
Multidimensional Analysis: The framework supports the analysis of traffic patterns across time, space, and user groups with precise quantification of system efficiency. It introduces a rotation mechanism to demonstrate how partial coordination (smart reservations) can improve system performance.
Computational Tractability: By leveraging tensor decomposition, automatic differentiation, and ADMM-based decomposition, the framework maintains computational feasibility for large-scale applications. It bridges the gap between theoretical models and practical deployment needs.
Integration of ML and Physics: The architecture provides a foundation for integrating data-driven ML approaches (e.g., for OD estimation) with physics-based flow propagation, ensuring that data-driven insights respect physical network constraints.

Results and Implementation

The paper presents theoretical derivations and conceptual benchmarks rather than extensive empirical case studies with new real-world data.

Theoretical Validation: The framework is validated through a Pigou network example, proving that the proposed rotation mechanism leads to Pareto improvements and a reduced Price of Anarchy for all $\beta \ge 1$ .
Computational Performance: The authors cite results from related open-source implementations (e.g., CG Choice Model, CG Equilibrium) to demonstrate efficiency:
- A multinomial logit model with 88 parameters converged in 8.6 seconds using the tensor-based approach, compared to 7–9 minutes for alternative methods.
- A nested logit model with 89 parameters converged in 30 seconds, outperforming methods taking over 15 minutes.
- A traffic assignment case study on a Fresno network (1,078 nodes, 6,000 OD pairs) achieved convergence within 600 seconds over 100 episodes with a relative gap under 1%.
Open-Source Ecosystem: The framework is supported by a suite of open-source repositories (e.g., CG Network Model, TCGlite, AVRLite) that implement the tensor-based architecture, ADMM integration, and column generation algorithms, adhering to the General Modeling Network Specification (GMNS).

Significance and Claims

The paper claims that the FTT framework represents a fundamental shift in transportation modeling by unifying disparate traditions into a single, differentiable computational graph.

Bridging Theory and Practice: It addresses the "gap" between theoretical transportation models (which often lack real-time data integration) and practical deployment needs (which require scalability and constraint enforcement).
Enabling Next-Generation Systems: The framework provides the mathematical foundation for next-generation integrated mobility systems, enabling real-time control strategies, efficient multimodal coordination, and rigorous enforcement of physical constraints.
Modest Scope: The authors explicitly state that while the framework demonstrates the potential for multi-dimensional scheduling and rotation strategies, the detailed operational mechanisms for implementing these strategies (e.g., specific mobility credit schemes or full trajectory scheduling for autonomous vehicles) are beyond the scope of this paper. The work serves as a conceptual benchmark and a foundation for future research in tensor-based scheduling and coordination.

In summary, the paper proposes a scalable, unified architecture that leverages tensor algebra and automatic differentiation to solve complex, multi-layer transportation optimization problems, offering a pathway to integrate AI, classical optimization, and physical network constraints.