🔬 physics

Programmable photonic implementation of nested Walsh parity filters in an eight-mode single-photon register

This paper experimentally demonstrates the implementation of programmable linear-optical Walsh filters on Quandela's Belenos photonic processor, successfully routing DC and face-parity components of an eight-mode single-photon register with high selectivity and quantifying the calibration-induced leakage floors that limit their performance.

Original authors: Emma Tully, Jonathan Washburn, Megan Simons

Published 2026-07-16

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Emma Tully, Jonathan Washburn, Megan Simons

Original paper licensed under CC BY 4.0 (https://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 world where light doesn't just carry a message like a flashlight beam, but can be shaped into a complex, invisible dance. This is the realm of quantum photonics, where scientists use individual particles of light called photons to do math and store information. Instead of using tiny switches like in your computer, these researchers use the "path" a photon takes through a maze of mirrors and glass tubes. Think of it like a marble rolling through a marble run; if you arrange the tubes just right, the marble can take many paths at once, creating a superposition of possibilities.

In this high-tech playground, there's a constant battle against "noise." Just as static on a radio can ruin a song, tiny imperfections in the glass or vibrations can mess up the photon's delicate dance, causing it to lose its information. Scientists are always looking for clever ways to filter out this noise. One powerful idea is to use parity checks. You might know this from checking if a number is even or odd. In the quantum world, if you have a group of light paths, you can check if their combined "sum" is zero (neutral) or if they have a specific pattern. If the pattern is broken, you know something went wrong. This paper explores how to build a machine that can instantly sort these light paths, keeping the "good" ones and throwing away the "bad" ones, all while using a single photon as the messenger.

The Great Light Filter: Sorting the Good from the Bad

Meet the Recognition Physics Institute team, led by Emma Tully, Jonathan Washburn, and Megan Simons. They decided to play a game of "spot the difference" with light, but on a scale so small it requires a supercomputer made of glass to see. They built a programmable photonic processor—a chip that acts like a giant, reconfigurable maze for a single photon. Their goal? To test a specific set of rules called nested Walsh parity filters.

To understand what they did, imagine you have a cube with eight corners (like a die, but with three dimensions). Each corner represents a different path the photon can take. The researchers wanted to see if they could program their light-maze to act like a bouncer at a club. The bouncer has a list of rules:

The "Zero-Sum" Rule: The total "weight" of the photon's presence across all eight paths must add up to zero. If it doesn't, the photon is "unbalanced" and gets kicked out.
The "Face-Parity" Rule: The cube has six faces (top/bottom, left/right, front/back). The bouncer also checks if the photon's presence on opposite faces balances out.

If the photon follows these rules, it's a "good" photon and gets to stay in the club. If it breaks the rules, it gets routed to a different exit so the scientists can see what went wrong.

The Experiment: A Cloud-Based Light Show

The team didn't build this maze in their basement; they used Quandela's Belenos processor, a cloud-accessible quantum computer. They sent over 340,000 single photons through this digital maze, one by one. It's like rolling a die 340,000 times, but the die is a single particle of light, and the rules are incredibly complex.

They tested two main things:

The Neutral Filter: They tried to keep photons that followed the "zero-sum" rule. In a perfect world, if a photon is perfectly balanced, it should never trigger the "bad" exit. In the real world, nothing is perfect. The team found that their filter was incredibly good at its job. When they sent in a "bad" photon (one that didn't follow the rules), it got caught about 31.6 times more often than a "good" photon. Even better, when they sent in a "good" photon, the chance of it accidentally getting kicked out (leakage) was tiny, hovering around 0.02% to 1%. This is like having a bouncer who lets 99 out of 100 good people in, but only accidentally kicks out 1 or 2.
The Syndrome Routing: This is the cool part. When a photon did break a rule, the machine didn't just say "Error!" It routed the photon to a specific exit based on which face-parity rule was broken. The cube has three pairs of opposite faces. The machine could tell if the photon messed up the top/bottom balance, the left/right balance, or the front/back balance. Crucially, this high accuracy (94% to 99%) applies specifically when the photon violates exactly one of these face-parity rules. It successfully routed these specific "single-face" errors to the correct exits. However, the paper clarifies that for more complex errors, or to fully identify the exact nature of a mistake and fix it, the machine would need to measure the phase of the light (complex-syndrome readout) and instantly adjust the path (feed-forward), which this experiment did not yet demonstrate. So, while the machine is excellent at spotting and sorting specific single-rule violations, it isn't yet a full detective that can solve every possible crime scene on its own.

The "Magic" of Repetition

One of the most interesting tests involved making the photon go through the maze multiple times. In many quantum systems, doing the same thing over and over makes things worse because errors pile up. The team applied their "neutral-sector" filter one, two, and three times in a row. Surprisingly, the photon didn't get worse. The "leakage" (the chance of a good photon getting kicked out) stayed low and didn't grow with each round. This suggests that the machine is very stable and that the "good" photons are truly safe inside their protected zone.

What It Is NOT (The Reality Check)

It's important to know what this paper doesn't do. The authors are very clear: this is not a full error-correction system that fixes mistakes on the fly. They didn't catch the bad photon, fix it, and send it back in. They just caught it and said, "Hey, you broke the rules." Also, they only tested this with single photons. If a photon gets lost (which happens a lot in real life), the machine doesn't see it because they only count the ones that make it to the end. So, while this is a fantastic filter for light that does arrive, it doesn't solve the problem of light disappearing.

The Verdict

The team successfully built a programmable light-maze that can sort photons based on complex mathematical rules with high precision. They proved that you can create a "neutral" zone where photons are safe from certain types of noise, and if they do get noisy, the machine can tell you exactly which part of the pattern broke—specifically for single-face violations.

The results show that with over 340,000 trials, they achieved a level of control where the "leakage" is just a few percent, and the ability to identify specific single-rule errors is nearly perfect. While this isn't a magic wand that fixes all quantum errors yet, it's a massive step forward in showing that we can build programmable filters that understand the geometry of light. It's like teaching a bouncer to not just check IDs, but to understand the entire vibe of the party and spot the troublemakers before they even cause a scene. The future of quantum computing might just depend on building better bouncers like these.

Technical Summary: Programmable Photonic Implementation of Nested Walsh Parity Filters

Problem Statement
Programmable photonic processors offer a flexible platform for high-dimensional unitary transformations on path and mode degrees of freedom. However, a critical near-term challenge is determining how faithfully ideal linear filters and syndrome-routing primitives can be prepared, compiled, and read out on available hardware. Specifically, there is a need to characterize the implementation accuracy of nested subspaces defined by classical error-correcting codes when realized as single-photon spatial-mode filters. This work addresses the question of how well a programmable photonic mesh can realize nested Walsh parity filters—specifically the [8, 7, 2] single-parity-check code and the [8, 4, 4] extended Hamming code (first-order Reed–Muller code)—and quantifies the leakage floors and syndrome-routing selectivity achieved in a real-world setting.

Methodology
The study was conducted on Quandela's cloud-accessible Belenos processor, a 24-mode universal photonic processor. The experiment utilized 8 logical modes indexed by the vertices of a three-dimensional hypercube ( $Q_3$ ).

Theoretical Framework: The modes were treated as a first-quantized spatial-mode vector. The "neutral subspace" ( $N$ ) was defined as the zero-sum hyperplane (DC check), and a smaller "parity-filtered subspace" ( $S$ ) was defined by three additional face-parity checks. These correspond to the classical [8, 7, 2] and [8, 4, 4] codes.
Error Model: The experiment adopted a "first-quantized path-mode error model," focusing on single-mode amplitude perturbations (e.g., local attenuation or imbalance). Errors with support weight greater than one were outside the scope of the specific checks tested.
Experimental Workflow:
1. State Preparation: Software-defined unitary transformations prepared single-photon states in specific neutral superpositions or parity-checked basis states.
2. Processing: States were routed through a "neutral-sector unitary core" ( $R_N$ ) applied 0 to 3 times, or directly to a separator.
3. Readout: A "BALANCE" separator routed the DC (uniform) component to a dump port, while a "parity separator" routed the DC and three face-parity syndrome components to resolved output ports.
4. Postselection: All reported probabilities were conditional on single-photon postselection (exactly one photon detected across eight ports), effectively removing photon loss from the tested error channel.
Data Volume: The study analyzed over 340,000 postselected single-photon detection events across six distinct experimental configurations.

Key Contributions

Hardware Characterization: This work provides a calibrated, reproducible hardware characterization of nested Walsh filters on a cloud-accessible programmable photonic processor. Unlike active error-correction demonstrations, this study focuses on the filtering and routing primitives themselves.
Leakage Quantification: The authors measured percent-level leakage floors for the neutral filter and identified specific calibration systematics (fixed-pattern biases, per-compilation scatter) that set these floors.
Syndrome Routing: The experiment demonstrated the resolution of DC and three face-parity syndrome channels with high selectivity, providing a confusion matrix for syndrome routing.
Soft Error Response: A calibrated, monotonic "soft response" to injected DC contamination was established, linking the magnitude of leakage to the degree of state preparation error.

Results

Neutral Filter Performance: Representative neutral inputs exhibited a leakage suppression of approximately $21\times$ relative to the ideal DC-capture baseline (and $31.6\times$ relative to a non-neutral control). The residual leakage was in the range of $0.02\%$ to $1.1\%$ , dominated by preparation and calibration imperfections rather than a failure of the linear sum constraint.
Parity-Filtered Subspace: Representative parity-filtered inputs showed a syndrome suppression of $23.7\times$ relative to a control. The three face-parity syndrome channels were resolved with dominant-port selectivity between $94\%$ and $99\%$ .
Depth Dependence: Repeated applications (1 to 3 cycles) of the neutral-sector unitary core did not show monotonic growth in leakage; leakage remained far below non-neutral controls. However, cross-depth differences were dominated by per-compilation calibration scatter rather than a per-cycle leakage rate.
Calibration Sensitivity: The experiment revealed that syndrome leakage is sensitive to the Walsh spectrum of per-mode calibration errors. An outlier in syndrome leakage for one specific basis state was attributed to state-dependent calibration asymmetry.
Coherence Verification: A control experiment involving a Hong–Ou–Mandel visibility drop (from $90.7\%$ to $21.2\%$ ) showed that the leakage suppression collapsed when photon indistinguishability was lost, confirming that the observed filtering relies on phase-coherent interference.

Significance and Claims
The paper modestly claims to demonstrate the faithful implementation of specific linear-algebraic primitives on hardware, rather than a full fault-tolerant error-correction cycle.

Scope: The work characterizes single-block filtering, leakage readout, and syndrome routing. It explicitly states it does not demonstrate active error correction, feed-forward recovery, a fault-tolerance threshold, or protection against photon loss.
Physical Resource: The significance lies in the realization of a reusable primitive for routing DC and face-parity components of a single-photon spatial-mode register to resolved ports.
Limitations: The authors note that the observed leakage floors are set by identifiable implementation systematics (calibration bias, scatter) and that the current setup measures intensity/probability only, lacking the complex-syndrome readout required for closed-loop correction.
Conclusion: The experiment validates that a programmable photonic mesh can realize nested Walsh filters with calibration-dependent percent-level leakage floors, providing a foundational primitive for future high-dimensional photonic quantum information processing.

The Great Light Filter: Sorting the Good from the Bad

The Experiment: A Cloud-Based Light Show

The "Magic" of Repetition

What It Is NOT (The Reality Check)

The Verdict

More like this