Steady Teleportation from Memory-Laden Quantum Storage

Quantum teleportation sends an unknown qubit state using a shared entangled pair plus two classical bits. It is usually scored by its average fidelity, meaning how close the received state is to the sent one, averaged over all possible inputs. A known weakness of that score is that a channel can look good on average while badly corrupting particular input states. Prior work therefore also tracks fidelity deviation: the spread of fidelity across inputs. That work assumes the noise on the entangled pair is a fixed, memoryless map. Real quantum memories do not behave that way. Their noise is non-Markovian: the environment remembers earlier disturbances, so the damage a stored pair suffers rises, falls, and sometimes partly reverses over time. In a quantum network, a pair is also held for a waiting time that varies from use to use.

The claim of this note is that, once memory matters, most of the unpredictability in teleportation comes from when the pair is used, not which state is sent. The across-inputs part of the spread can be removed by a cheap, standard trick. The across-time part cannot. We propose to measure the two parts separately and to remove the time part by designing control pulses applied while the pair sits in storage. The pulses are chosen so that the stored pair stays both isotropic (equally good for every input) and roughly equally good at every possible retrieval time. We optimize them by alternating between a closed-form step for the local reference frames and a gradient step for the pulse amplitudes.

Core Claim

Let the waiting time $\tau$ be random, drawn from a known distribution $p(\tau)$ set by the network protocol. Let $F(\psi,\tau)$ be the fidelity of teleporting input $\psi$ after waiting $\tau$. By the law of total variance, the spread of fidelity over the joint ensemble of inputs and waiting times splits into two parts:

$$D_{\text{tot}}^2 \;=\; \mathbb{E}_{\tau}\big[\delta(\tau)^2\big] \;+\; \mathrm{Var}_{\tau}\big[F(\tau)\big].$$

Here $\delta(\tau)$ is the across-input deviation of the stored state at time $\tau$, and $F(\tau)$ is its input-averaged fidelity. The first term is what prior fidelity-deviation work studies. The second term appears only when storage time varies and the noise has dynamics.

Our target is the score $J = \mathbb{E}_{\psi,\tau}[F] - k\,D_{\text{tot}}$. This generalizes the teleportability score $F - kD$ of Rating the performance of noisy teleportation using fluctuations in fidelity, with $k$ the user's intolerance to fluctuation, from fixed noise to a joint ensemble over inputs and retrieval times.

We make three predictions. First, a known operation removes the first term at no cost in average fidelity, at every $\tau$. Second, under realistic memory kernels the second term is the larger one and is non-monotonic in $\tau$. Third, storage pulses optimized for $J$ shrink it substantially compared with pulses designed for average fidelity or under a memoryless noise model.

The first prediction is an honest concession that shapes the whole proposal. For a two-qubit resource state, the across-input deviation depends only on the singular values of the correlation matrix $T$, with entries $t_{ij} = \mathrm{Tr}(\rho\,\sigma_i\otimes\sigma_j)$. The deviation vanishes exactly when the three singular values have equal magnitude. Both results are from Fidelity deviation in quantum teleportation with a two-qubit state, which supplies our per-time evaluation formula. A local alignment followed by a random correlated "twirl" (Alice and Bob apply matched random rotations using shared classical randomness) turns any state into a Werner state, the isotropic mixture of a Bell state with noise. Werner states are the zero-deviation family among Bell-diagonal states, per the same paper, and the twirl keeps the best achievable fidelity. This fits the existence result there that a zero-deviation state exists at every achievable fidelity above the classical limit of 2/3.

Optimizing local rotations alone at teleportation time is therefore pointless for uniform inputs. Rotations do not change singular values, and the twirl already zeroes the input spread. The across-time term is what remains open.

Why this gap is real

Two lines of work motivate the gap. On the fidelity-deviation side, Rating the performance of noisy teleportation using fluctuations in fidelity shows that memoryless noise reorders which resource states are best. Under local bit-flip noise at $k=2.5$, a partially entangled state with $\alpha\approx 0.15$ beats the Bell state. Global depolarizing noise can even raise the score by flattening the fidelity distribution. Optimal two-qubit states for quantum teleportation vis-à-vis state properties solves the joint "best fidelity, zero deviation" problem analytically, but only under fixed constraints on entropy, concurrence or Bell violation. Gain in performance of teleportation with uniformity-breaking distributions shows that rotating inputs to match the channel's strong axes helps when inputs are non-uniform. All three treat the noisy resource as a single fixed matrix $T$.

On the noise side, Non-Markovian Noise Characterization with the Transfer Tensor Method reconstructs memory kernels from tomography snapshots. On IBM Q Melbourne it finds memory persisting about 1 μs, roughly ten times a 100 ns gate. It also finds non-monotonic reachable-state volume, a sign that information flows back from the environment. Randomized Benchmarking for Non-Markovian Noise shows that memory bends benchmarking decay curves away from a single exponential. It also warns that some memory models still look exponential, so averaged scalars can hide memory. Park et al. find that generalized Bloch equations fail near zero frequency, where much of the noise power lies.

Taken together, these predict that the singular values $|t_{ii}(\tau)|$ of a stored pair will not shrink smoothly and together. They will shrink unevenly and sometimes partly recover. That makes both $\delta(\tau)$ and $F(\tau)$ wiggle with $\tau$, and nobody in this literature has computed that.

The method comes from control. Optimal Control of a Qubit Coupled to a Non-Markovian Environment extends gradient pulse engineering (GRAPE) to a qubit coupled to a two-level fluctuator, a single switching defect in contact with a thermal bath. It finds "self-refocusing" pulses that use bath memory to undo errors, cutting gate error by about an order of magnitude relative to Rabi pulses. That objective is a single average gate fidelity at a fixed end time, for one qubit, with no notion of input spread or uncertain stopping time. We reuse its open-system model and gradient machinery. We change what is optimized (the joint score $J$ over a two-qubit memory) and when it is evaluated (at every truncation time weighted by $p(\tau)$).

The alternating structure follows Binary Control Pulse Optimization for Quantum Systems, which splits a hard control problem into easier alternating subproblems. It also follows Intelligent Reflecting Surface Aided Multi-User mmWave Communications for Coverage Enhancement, where alternating between two coupled blocks of variables converges in 5 to 10 iterations.

Research Program

The physical setting is a heralded entangled pair loaded into two memory qubits. The qubits wait a random time $\tau$ and are then consumed by teleportation. Each qubit is coupled to a non-Markovian environment. We study two environment models. The first is the fluctuator-plus-bath model of Rebentrost et al., scanned over switching rates including the resonant regime where they found gate error peaks. The second is a dephasing model whose memory kernel is fit to the 1 μs scale reported by Chen et al. The waiting-time distribution $p(\tau)$ is geometric or uniform over a window spanning several memory times. This places the interesting dynamics inside the window.

The controllable variables fall into two blocks. Block one is a pre-storage local frame for each memory qubit (a rotation before the pair is stored) and a post-storage correction that depends on $\tau$. Bob knows the heralded waiting time, so the correction can use it. Pre-storage rotations do matter, even though post-storage rotations do not, because the environment's coupling picks out preferred axes. Rotating the pair relative to those axes changes which correlations get damped. Block two is a piecewise-constant pulse sequence on each memory qubit during storage.

The alternation runs as follows. With the pulses fixed, the best post-storage correction at each $\tau$ comes in closed form from the singular value decomposition of $T(\tau)$, an orthogonal-Procrustes-type alignment. The pre-storage rotations are searched over a six-dimensional rotation manifold. With the frames fixed, the pulse amplitudes are updated by open-system GRAPE on $J$. Here $\delta(\tau)$ comes from the Ghosal et al. closed form and $F(\tau)$ from the standard singular-value expression, both differentiable in $T(\tau)$.

Every $\tau$ in the support of $p(\tau)$ is a possible stopping point. The pulses must therefore work well when truncated at any time, not just at a designed end point. That requirement is what makes them different from ordinary refocusing sequences, which only refocus at the end of a full cycle.

The analysis component maps memory-kernel shape (decay time, oscillation, coupling anisotropy) to the size of each variance term in the uncontrolled case. It also asks whether the "stabilizer effect" of depolarizing noise survives information backflow.

Baselines

The naive reference point stores the pair with no pulses and teleports with the standard protocol and no correction. It shows the raw size of both variance terms.

The strongest baseline for the across-input term is alignment plus twirl. This is the best $\tau$-conditioned local alignment followed by a random correlated Werner-izing twirl. It is cheap, needs only shared randomness, and should drive $\mathbb{E}_\tau[\delta^2]$ to zero. Any method that does not beat it on $D_{\text{tot}}$ adds nothing. We apply the same twirl on top of every pulse method, so comparisons isolate the across-time term.

The strongest baseline for pulses is open-system GRAPE optimizing average fidelity at the mean waiting time, as in Optimal Control of a Qubit Coupled to a Non-Markovian Environment. That paper reports roughly an order-of-magnitude gate-error reduction relative to Rabi pulses and fidelities reaching the $T_1$ limit. We found no reported result on Lacuna for teleportation fidelity or fidelity deviation from a pulse-protected memory under non-Markovian noise. We also include a standard periodic refocusing sequence, again with no reported result found on Lacuna for this setting.

A memoryless-model ablation isolates the role of non-Markovian modeling. We optimize the same objective $J$ under a Lindblad model fitted to the same environment's effective relaxation and dephasing times, then evaluate on the true memory model.

A cutoff-policy baseline discards pairs older than a threshold, a natural network practice. It is compared at matched yield, meaning the same fraction of pairs actually used.

All pulse methods share the same environment simulator, pulse discretization, amplitude limits and number of objective-and-gradient evaluations. Each is tuned with the same random restarts.

Beating the baselines means a statistically clear reduction in $D_{\text{tot}}$ at equal or higher $\mathbb{E}[F]$, across at least two environment models and three values of $k$. In practice the reduction must come from the across-time term, because twirling ties every method on the across-input term.

Why not just…?

Why not just twirl the stored pair into a Werner state? This fully handles the across-input term, which is why we adopt it rather than compete with it. It cannot touch $\mathrm{Var}_\tau[F(\tau)]$. Twirling preserves, but does not raise, the best fidelity at each $\tau$, and that fidelity is set by how much correlation the memory retained. The first experiment measures exactly how much variance survives twirling. If that residual is small for realistic kernels, the proposal's premise fails, and we will report it.

Why not just reuse average-fidelity GRAPE or a standard refocusing sequence? These are tuned for a known end time. Self-refocusing pulses of the kind found by Rebentrost et al. may look poor if truncated mid-sequence, because their errors cancel only at the end. This is a real threat when $p(\tau)$ is narrow, and we expect the baselines to match us there. The decisive test sweeps the width of $p(\tau)$ from a point mass to the full memory window. The proposal predicts the gap opens as the distribution widens.

Why not just optimize everything jointly by gradient descent instead of alternating? This may work equally well, and we treat that as a live possibility. The case for alternation is that the frame block has an exact closed-form or low-dimensional global solution given the pulses. Gradient descent can stall on the rotation manifold, a pattern the alternating designs of the binary-control and reflecting-surface papers exploit. We run joint gradient descent with matched evaluations and restarts. If it ties, the contribution is the variance decomposition and the any-time objective, not the optimizer, and we will say so.

Why not just model the noise as memoryless? Park et al. and Chen et al. show that memoryless models misrepresent low-frequency noise and kernels lasting about ten gate times. The memoryless-model ablation tests directly whether that misrepresentation costs anything on $J$.

Proposed Experiments

Experiment one is a simulation study with no control. It computes both variance terms versus memory time, oscillation strength and coupling anisotropy, with and without twirling. It also reproduces the memoryless sanity check that the best resource state under local bit-flip at $k=2.5$ has $\alpha\approx 0.15$, from Rating the performance of noisy teleportation using fluctuations in fidelity. The decisive check is whether the across-time term exceeds the across-input term in the realistic-kernel regime. It also asks whether backflow makes $F(\tau)$ non-monotonic, which would show that the depolarizing "stabilizer effect" does not carry over to memory noise.

Experiment two runs the full baseline comparison above across switching rates and waiting-time widths. It reports $\mathbb{E}[F]$, $D_{\text{tot}}$, each variance term, the worst-case fidelity over $(\psi,\tau)$, and optimizer wall-clock time.

Experiment three is a robustness test. Pulses are optimized on one kernel and evaluated on perturbed kernels. This tells us whether the method needs accurate characterization.

Experiment four is a small hardware check on an IBM superconducting device. We would characterize the idle-qubit memory kernel with the transfer tensor procedure of Chen et al. and then compare optimized versus baseline idle pulses on a stored Bell pair. Fidelity is estimated from state tomography of the stored pair as a function of idle time, and the deviation is computed in closed form. Following the caution in Randomized Benchmarking for Non-Markovian Noise, we report the full fidelity-versus-time curve rather than a fitted decay rate. A deceptively exponential average could otherwise hide the very variance we target.