⚛️ quantum physics

Parity-Based Time-Bin Encoding Enabling SWAP Between Polarization and Time-Bin Qubits

This paper introduces a parity-based time-bin encoding that enables a deterministic SWAP operation between polarization and time-bin qubits by utilizing physical delays to implement logical flips, thereby overcoming the limitations of conventional encoding and facilitating multi-degree-of-freedom photonic quantum processing.

Original authors: Adam Sultan, Connor Kupchak

Published 2026-07-30

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Adam Sultan, Connor Kupchak

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 build a super-fast, super-secure internet using tiny packets of light called photons. In the world of quantum computing, these photons are the messengers carrying our most precious data. But here's the tricky part: to make these computers powerful, we need to do more than just send light from point A to point B. We need to shuffle information around inside a single photon. Think of a photon like a tiny, magical courier that can carry two different types of packages at once: one package is wrapped in a specific color (polarization), and the other is wrapped in a specific arrival time (time-bin).

To make these quantum computers work, we often need to swap these packages. We might want to take the information from the "color" package and move it to the "time" package, or vice versa, without losing a single bit of the secret message. This is called a "SWAP" operation. It's like a choreographed dance where two dancers switch places perfectly. The problem is, the old way of organizing these "time" packages was a bit clumsy. It was like a one-way street: you could move a package from an early arrival time to a late one, but you couldn't easily move it back. This made the dance impossible to perform in reverse, blocking us from building the complex circuits needed for future quantum networks.

This paper introduces a clever new way to organize those time packages to solve this one-way street problem. Instead of labeling times as simply "early" or "late," the authors suggest labeling them by "parity"—whether they are even or odd multiples of a specific time interval. Imagine a train track where every other station is painted blue and the ones in between are painted red. If you move a train forward by exactly one station, it automatically switches from blue to red, or red to blue, no matter where it started. This simple trick turns a one-way street into a two-way street. By using this "parity-based" system, the authors show how to build a machine that can swap the color and time information of a single photon back and forth, using standard optical tools like mirrors and crystals. This isn't just a theoretical idea; they map out exactly how to build it and calculate the timing needed to make it work, providing a new, essential tool for connecting different parts of a future quantum computer.

The Problem: The One-Way Street of Time

In the world of light-based quantum computing, information is often stored in two main ways. First, there's polarization, which is like the direction a light wave wiggles (up-and-down vs. side-to-side). Second, there's time-bin encoding, where information is stored in when the photon arrives. In the old, "conventional" method, scientists used "early" and "late" windows to represent the two states of a time qubit (0 and 1).

The problem with this old method is that it's inherently one-directional. If you have a photon in the "late" window and you want to move it to the "early" window, you can't just add a delay. Adding a delay only pushes things later. You can't push a late photon back to being early. This creates a dead end. To perform a "SWAP" (exchanging the information between the polarization and the time), you need to be able to flip the time qubit from 0 to 1 and from 1 to 0, depending on the polarization. The old system simply couldn't do the "late to early" flip, making the full swap impossible.

The Solution: The Even-Odd Grid

The authors propose a new way to label time, which they call parity-based time-bin encoding. Instead of "early" and "late," they define the states based on whether the photon arrives at an even or odd multiple of a specific time interval, let's call it $\Delta t$ .

Even multiples of $\Delta t$ represent the logical state $|0\rangle_T$ .
Odd multiples of $\Delta t$ represent the logical state $|1\rangle_T$ .

Here is the magic: If you delay a photon by exactly one interval ( $\Delta t$ ), it moves from an even number to an odd number, or from an odd number to an even number. It doesn't matter if the photon was at the very start of the "even" window or the very end; adding $\Delta t$ always flips its parity.

Think of it like a checkerboard. If you are on a white square (even) and you move one step forward, you land on a black square (odd). If you are on a black square and move one step, you land on a white square. This works in both directions. This simple change means that a physical delay line (a piece of glass that slows light down) can now act as a "switch" that flips the time qubit, regardless of whether it was "early" or "late" in the old sense.

The Dance: How the SWAP Works

With this new encoding, the authors show how to build a SWAP gate. A SWAP gate is a quantum operation that exchanges the states of two qubits. In this case, it swaps the polarization information with the time-bin information.

The paper proves that you can build this SWAP gate by chaining together three simpler operations called CNOT gates (Controlled-NOT). A CNOT gate flips one qubit only if the other qubit is in a specific state. The sequence they use is:

CNOT from Polarization to Time: If the photon is vertically polarized, flip its time parity.
CNOT from Time to Polarization: If the photon is in an odd time bin, flip its polarization.
CNOT from Polarization to Time: Again, if the photon is vertically polarized, flip its time parity.

When you do these three steps in a row, the information that was in the polarization ends up in the time-bin, and the information that was in the time-bin ends up in the polarization. It's a perfect exchange.

Building the Machine

The paper doesn't just stop at the math; it maps out how to build this with real hardware:

To flip the time based on polarization (CNOT $_{P \to T}$ ): They use a Polarization Beam Splitter (PBS). This device splits the light into two paths based on its color (polarization). One path is short, and the other is longer by exactly $\Delta t$ . When the paths recombine, the time-bin has been flipped only if the photon took the long path.
To flip the polarization based on time (CNOT $_{T \to P}$ ): They use an Electro-Optic Modulator (EOM). This is a device that can change the polarization of light very quickly when you apply a voltage. By syncing the voltage waveform with the arrival times of the photons, the device flips the polarization only if the photon arrives at an "odd" time.

The full architecture involves three stages: a delay stage, a modulator stage, and another delay stage. The authors show that this setup works deterministically, meaning it should work every time, provided the timing is precise.

The Fine Print: Timing and Limits

Of course, building this requires perfect timing. The paper dives into the practical constraints of making this work in a real lab.

The Time Interval ( $\Delta t$ ): The gap between the "even" and "odd" bins needs to be large enough to let the electronics switch on and off. The authors suggest a practical starting point of 1 nanosecond ( $\Delta t = 1 \text{ ns}$ ).
Switching Speed: The device that flips the polarization (the EOM) needs to switch faster than the time interval. They estimate a switching time ( $\tau_{switch}$ ) of about 100 picoseconds and a stable sampling window ( $\tau_{open}$ ) of 300 picoseconds.
The Total Time: When you add up the time needed for the switching, the stable window, the detector response, and some safety margin for jitter (timing errors), the total time for one full SWAP operation comes out to be approximately 2.5 nanoseconds.

This translates to a potential gate rate of about 400 MHz, which is quite fast for quantum operations. However, the authors are careful to note that this is an ideal rate. In a real experiment, factors like light loss in the fibers, detector dead time (when the detector is too busy to see a new photon), and other inefficiencies will slow things down.

Why This Matters

The main takeaway isn't just that they found a way to swap qubits; it's that they found a way to do it using standard optical components by changing how we think about time. By moving away from the "early/late" mindset to an "even/odd" mindset, they unlocked the ability to perform bidirectional operations that were previously blocked.

This work provides a "routing primitive," which is a fancy way of saying a basic building block for connecting different parts of a quantum circuit. Just as a computer needs wires to move data between the processor and memory, a photonic quantum computer needs ways to move information between different types of encodings (like polarization and time). This parity-based encoding makes that possible, paving the way for more complex and scalable quantum networks. The authors present this as a concrete, physically realizable architecture, though they acknowledge that a full hardware-level analysis of errors and specific component limits is a necessary next step for experimentalists.

Technical Summary: Parity-Based Time-Bin Encoding Enabling SWAP Between Polarization and Time-Bin Qubits

Problem Statement
Linear-optical quantum architectures face scalability challenges, prompting the exploration of multi-degree-of-freedom (DOF) encoding where a single photon carries multiple qubits (e.g., polarization and time-bin). While routing information between these encodings is essential for compact multi-qubit operations, a deterministic SWAP gate between polarization and time-bin qubits has been difficult to implement. The primary obstacle lies in conventional "early/late" time-bin encoding: a fixed physical delay can move a photon from an early to a late window, but it cannot reverse this process (late to early) without complex active switching. Consequently, a polarization-controlled delay line cannot implement the bidirectional logical flip ( $|0\rangle_T \leftrightarrow |1\rangle_T$ ) required for a Controlled-NOT (CNOT) gate where polarization is the control and time-bin is the target ( $CNOT_{P \to T}$ ).

Methodology
The authors propose a novel parity-based time-bin encoding to overcome the unidirectional limitation of conventional schemes.

Encoding Definition: Instead of mapping logical states to specific temporal windows (early/late), logical $|0\rangle_T$ and $|1\rangle_T$ are defined as even and odd multiples of a fixed time spacing $\Delta t$ , respectively.
Mechanism: Under this encoding, a physical delay of exactly $\Delta t$ toggles the logical time-bin state regardless of the photon's specific arrival instant within its bin. An even bin becomes odd, and an odd bin becomes even.
Gate Composition: The SWAP operation is decomposed into three sequential CNOT gates using the standard identity $SWAP = CNOT_{P \to T} \cdot CNOT_{T \to P} \cdot CNOT_{P \to T}$ $S W A P = C N O T_{P \to T} \cdot C N O T_{T \to P} \cdot C N O T_{P \to T}$ .
1. $CNOT_{P \to T}$ : Implemented using a polarization-dependent delay line (PBS-split, delay $\Delta t$ on the vertical arm, recombine). The polarization state controls whether the time-bin parity flips.
2. $CNOT_{T \to P}$ : Implemented using an Electro-Optic Modulator (EOM) or an optical Kerr switch. The device is synchronized to the $\Delta t$ grid, applying a polarization rotation (H $\leftrightarrow$ V) only when the photon arrives in an "odd" time bin.
3. Final $CNOT_{P \to T}$ : A second polarization-dependent delay line completes the sequence.

Key Contributions

Parity-Based Encoding: The introduction of a time-bin encoding based on temporal parity (even/odd multiples of $\Delta t$ ) rather than absolute arrival time. This is the critical enabler that allows a fixed passive delay to function as a logical bit-flip.
Deterministic SWAP Architecture: A complete optical circuit utilizing standard components (PBS, delay crystals, EOMs) to deterministically swap quantum information between polarization and time-bin qubits on a single photon.
Synchronization Strategy: The alignment of the parity grid with the drive waveform of an EOM (or Kerr switch), enabling time-conditioned polarization rotations.

Results and Analysis

Theoretical Proof: The paper provides a basis-state proof demonstrating that the three-CNOT sequence correctly maps an input state $(\alpha|H\rangle + \beta|V\rangle) \otimes (\gamma|even\rangle + \delta|odd\rangle)$ to the swapped state $(\gamma|H\rangle + \delta|V\rangle) \otimes (\alpha|even\rangle + \beta|odd\rangle)$ .
Experimental Constraints: The authors analyze the timing requirements for experimental realization. The time-bin spacing $\Delta t$ must satisfy $\Delta t \gtrsim \tau_{switch} + \tau_{open} + \tau_{det} + \sigma_{jitter}$ , where $\tau_{switch}$ is the EOM rise/fall time, $\tau_{open}$ is the stable sampling window, $\tau_{det}$ is detector aperture, and $\sigma_{jitter}$ is system timing jitter.
Feasibility Estimates: Using realistic parameters (e.g., $\tau_{switch} \approx 100$ ps, $\tau_{open} \approx 300$ ps), the authors estimate a practical $\Delta t$ of 1 ns. This yields a minimum gate time of approximately 2.5 ns for the full three-stage sequence, corresponding to an ideal gate rate of $\approx 400$ MHz, excluding optical losses and detector dead times.
Error Analysis: The paper quantifies polarization-rotation errors arising from EOM drive voltage drift, showing that the flip probability deviates from unity based on the fractional voltage error $\epsilon_V$ .

Significance and Claims
The paper claims that the parity-based time-bin encoding is the "enabling ingredient" that makes a polarization-controlled delay line implement a $CNOT_{P \to T}$ gate, a feat impossible with conventional early/late encoding. By combining this encoding with synchronized electro-optic modulation, the authors present what they state is the first complete SWAP architecture between time-bin and polarization qubits built entirely from standard optical components.

The work positions this SWAP gate not as a standalone novelty, but as a fundamental "routing primitive" for multi-degree-of-freedom photonic circuits. It enables the coherent exchange of quantum information between different DOFs, facilitating complex operations such as the polarization Toffoli gate. The authors maintain a modest scope, noting that their analysis is currently at the unitary level and that a full hardware-level budget (accounting for specific EOM bandwidth limits and detector jitter statistics) is required for practical implementation.