⚛️ quantum physics

QCNN with Rough Path Signature Kernels

This paper proposes a hybrid quantum-classical architecture for time series classification that integrates path signature kernels to handle time reparameterization invariance and employs a Quantum Convolutional Neural Network (QCNN) for downstream learning, demonstrating its potential through experiments on handwritten digit data while analyzing the computational constraints of its variational linear solver components.

Original authors: Leonardo Nogueira Falabella, Vasily Sazonov

Published 2026-07-09

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Leonardo Nogueira Falabella, Vasily Sazonov

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 trying to teach a computer to recognize handwritten numbers, like the "0" and "1" on a piece of paper. Usually, computers look at these as static pictures made of pixels. But in reality, a hand writing a "0" is a movement—a path that starts, loops, and ends.

The problem is that people write at different speeds. One person might write a "0" slowly and carefully, while another scribbles it quickly. To a standard computer, these look like two completely different shapes, even though they are the same number. This is the "time reparameterization" problem: the computer gets confused by how fast the path was drawn, rather than what the path actually is.

This paper proposes a clever solution using Quantum Computing to solve this specific problem. Here is how they did it, broken down into simple steps:

1. The "Fingerprint" of a Movement (Rough Path Signatures)

Instead of looking at the raw drawing, the authors use a mathematical tool called a Signature. Think of a signature as a unique "fingerprint" for a movement.

The Analogy: Imagine you are describing a dance move to a friend. You don't need to say "I moved my left foot at 2 seconds, then my right at 2.5 seconds." You just describe the shape of the move. The signature captures the essential shape and geometry of the path, ignoring the speed. Whether you dance it fast or slow, the "signature" remains the same. This solves the speed problem.

2. The Quantum Shortcut (Signature Kernels)

Calculating these signatures is usually very hard and slow for computers, like trying to count every single grain of sand on a beach to describe the beach's shape.

The Innovation: The authors use a mathematical trick called a Kernel. Instead of counting every grain of sand, the kernel gives you a single number that tells you how similar two paths are.
The Quantum Twist: They tried to use a Quantum Computer to do this calculation. They turned the math problem into a giant puzzle (a system of linear equations) and tried to solve it using a Variational Quantum Linear Solver (VQLS). This is like asking a quantum robot to solve a maze for you.

3. The Reality Check (Why the Robot Struggled)

The authors tried to run this quantum robot on current technology (called NISQ devices).

The Problem: The puzzle was too big. As the handwriting got more detailed (more time steps), the quantum robot got overwhelmed. It's like trying to solve a 1,000-piece puzzle with a tiny, noisy pair of tweezers. The robot couldn't find the right answer because the "noise" in the machine and the size of the puzzle were too much.
The Result: They had to switch back to a classical computer to do the heavy lifting of calculating the signatures. However, they kept the idea of the quantum approach for the next step.

4. The Quantum Brain (QCNN)

Once they had the "fingerprint" (the signature data), they fed it into a Quantum Convolutional Neural Network (QCNN).

The Analogy: Think of a QCNN as a special brain made of quantum bits (qubits). It takes the data and looks for patterns.
The Experiment: They tested two ways to feed this brain:
1. Pure Signature: Feeding the brain only the mathematical fingerprint of the movement.
2. Hybrid Fusion: Feeding the brain the original picture of the number plus the fingerprint as a little extra hint on a separate "channel."

5. The Outcome

They tested this on a dataset of handwritten 0s and 1s.

What Worked: The "Hybrid Fusion" approach (Picture + Fingerprint) worked the best. It was like giving the brain the photo of the number and a secret note saying "this was drawn slowly." This combination helped the quantum brain make better decisions than just looking at the photo alone.
What Didn't Work: The fully quantum method for calculating the signatures (the quantum robot solving the maze) was too slow and unstable for the current hardware.

Summary

The paper is a proof-of-concept. It shows that:

Using "signatures" is a great way to teach computers to ignore speed differences in handwriting.
Mixing these signatures with quantum neural networks can improve how well a quantum computer recognizes patterns.
However, the specific quantum tool they tried to use for the math part (VQLS) isn't ready for real-world, complex data yet. We still need better, less noisy quantum computers to make the whole process run entirely on quantum hardware.

In short: They built a bridge between the math of movement and quantum computing. The bridge is strong, but the road leading to it (the quantum calculator) is currently a bit bumpy.

Technical Summary: QCNN with Rough Path Signature Kernels

Problem Statement
Time series analysis faces a fundamental challenge: the invariance of sequential data to time reparametrization. Standard machine learning models, which rely on explicit time parametrization, struggle to extract meaningful features when data undergoes arbitrary accelerations, decelerations, or nonlinear warping. While Rough Path Theory offers a solution via the "signature" transform—an infinite-dimensional feature vector of iterated integrals that is inherently invariant to time reparametrization—computing these features is computationally prohibitive. The number of terms grows exponentially with path dimension and truncation order. Although signature kernels (inner products of signatures) offer a way to bypass explicit feature computation by solving a second-order hyperbolic partial differential equation (PDE), the resulting linear systems for discretized kernels remain large and sparse, creating a bottleneck for large-scale applications.

Methodology
The authors propose a hybrid quantum-classical architecture designed to address time series classification by integrating Rough Path Signatures with Quantum Convolutional Neural Networks (QCNNs). The pipeline consists of two primary stages:

Signature Kernel Computation (Feature Layer):
The core innovation is the computation of the signature kernel between a reference path and a target path. The kernel is defined as the solution to a Goursat problem (a specific PDE). The authors explore two methods for solving the discretized linear system ($Ax=b$) derived from the finite-difference scheme of this PDE:
- Variational Quantum Linear Solver (VQLS): A quantum approach where the solution is encoded in a parametrized quantum state. The matrix $A$ is decomposed into a linear combination of unitaries, and a hardware-efficient ansatz (alternating layers of single-qubit $Y$ rotations and CNOT gates) is optimized using a local cost function to minimize the overlap with the target state.
- Classical Solvers: As a baseline and practical alternative, the authors utilize classical numerical solvers (specifically the sigkernel library) to evaluate the kernel.
Quantum Classification (QCNN Layer):
The computed kernel features are fed into a QCNN. The authors investigate three specific architectural configurations for the binary classification task (distinguishing handwritten digits 0 vs. 1):
- Standard: Raw pixel data encoded into an 8-qubit register.
- Pure Kernel Substitution: The full signature kernel matrix (flattened) replaces the image data as the input to an 8-qubit QCNN.
- Auxiliary Qubit Fusion: A multimodal approach where the original image data is encoded into 8 qubits, while a single scalar value (the bottom-right element of the kernel matrix, representing full-path interaction) is encoded onto a 9th auxiliary qubit via a parameterized $R_Y$ rotation.

Key Contributions and Experimental Setup
The paper evaluates these architectures on a binary classification task using the MNIST dataset, specifically the subset of digits 0 and 1 converted into time-ordered stroke sequences. The experiments were conducted on noiseless statevector simulators using Qiskit for quantum circuits and PennyLane for QCNN optimization.

VQLS Scalability Analysis: The authors rigorously tested the VQLS component. They found that while VQLS converges for highly compressed paths (3–4 time steps), it fails to scale to realistic sample sizes (e.g., 5–6 time steps). The system dimension scales as $O(T^2)$ , and the matrix condition number $\kappa$ inflates rapidly, causing the optimization landscape to become non-convex and leading to a degradation in overlap fidelity. Consequently, the authors concluded that VQLS is currently unfeasible for multi-sample training loops without severe lossy compression.
Architecture Comparison: Due to the VQLS limitations, the subsequent performance benchmarks utilized classical kernel evaluation. The study compared the "Standard" image-only model against the "SigKernel" (pure kernel) and "SigKernel aux qubit" (fusion) models across various convolutional ansatzes (UTTN, Heuristic circuits U5–U15, and group-theoretic USO(4)/USU(4)).

Results

VQLS Limitations: The VQLS approach is currently restricted to heavily compressed sequences due to qubit count requirements (minimum 10 fully connected qubits for small datasets) and the rapid inflation of the condition number, which traps optimizers in local minima.
Classification Performance: The inclusion of signature kernel features provided distinct performance enhancements for specific QCNN architectures. Notably, the Auxiliary Qubit Fusion Architecture consistently outperformed the pure kernel substitution model across most tested ansatzes. This suggests that preserving the original spatial image structure while incorporating path signatures as an orthogonal, auxiliary quantum feature is a more effective strategy than replacing spatial data entirely with kernel matrices.
Data Constraints: The experiments required downsampling input paths to 16 points (15 time intervals) to fit the 8-qubit register constraints. The authors acknowledge this introduces a trade-off, potentially discarding fine geometric nuances necessary for robust classification.

Significance and Claims
The paper positions this work as a proof-of-concept for quantum-enhanced time series analysis. The authors claim that their framework successfully demonstrates the potential advantages of implementing path signature kernel layers within quantum circuits, specifically showing that hybrid architectures can leverage the time-reparametrization invariance of signatures to improve classification accuracy.

However, the authors maintain a modest tone regarding the current state of the technology. They explicitly state that the computational limitations of the VQLS component on Near-Term Intermediate-Scale Quantum (NISQ) devices currently prevent end-to-end quantum acceleration for signature kernels. The significance of the work lies in establishing a mathematical and architectural bridge between rough path theory and QCNNs, highlighting that while full quantum acceleration is not yet feasible, the structural priors provided by signature kernels can meaningfully improve quantum classifiers when integrated via hybrid classical-quantum workflows. The authors identify future directions as improving VQLS trainability (e.g., via QAOA-based ansatzes) and extending these methods to multi-class classification and real noisy hardware.