A Mathematical Structure for Amplitude-Mixing Error-Transparent Gates for Binomial Codes

TL;DR

This work develops a modular framework—parity-nested operations—to construct amplitude-mixing, error-transparent gates for binomial (rotation-symmetric) codes. It shows that achieving ET against photon-loss errors up to distance $l$ requires $\left\lfloor \tfrac{l}{2} \right\rfloor+1$ orders of generalized squeezing, while a single squeezing order can ET to all correctable jump errors $\mathcal{A}_l$. The constructions are demonstrated with explicit examples (e.g., $N=K=3$) and backed by numerical simulations that match the predicted ET scalings, offering a path toward high-fidelity, fault-tolerant logical operations in bosonic codes. The work also outlines possible experimental routes (MEM-based squeezing drives, multi-frequency control) and discusses extension to other hard-cutoff rotation-symmetric codes and ancilla-error transparency, highlighting the practical challenges and future directions for implementing ET amplitude-mixing gates. Overall, parity-nested ET gates complete the set of error-transparent operations for binomial codes and point toward scalable, noise-biased quantum computation in bosonic platforms.

Abstract

Bosonic encodings of quantum information offer hardware-efficient, noise-biased approaches to quantum error correction relative to qubit register encodings. Implementations have focused in particular on error correction of stored, idle quantum information, whereas quantum algorithms are likely to desire high duty cycles of active control. Error-transparent operations are one way to preserve error rates during operations, but, to the best of our knowledge, only phase gates have so far been given an explicitly error-transparent formulation for binomial encodings. Here, we introduce the concept of 'parity nested' operations, and show how these operations can be designed to achieve continuous amplitude-mixing logical gates for binomial encodings that are fully error-transparent to the photon loss channel. For a binomial encoding that protects against l photon losses, the construction requires $\lfloor$l/2$\rfloor$ + 1 orders of generalized squeezing in the parity nested operation to fully preserve this protection. We further show that error-transparency to all the correctable photon jumps, but not the no-jump errors, can be achieved with just a single order of squeezing. Finally, we comment on possible approaches to experimental realization of this concept.

Figures (4)

• Figure 1: Parity nesting schematic concept. General procedure for constructing a 'parity-nested' error-transparent $\bar{X}(\theta)$ gate for a binomial code, depicted here with order $N = 3$ and cutoff $K = 3$ (see Sec. \ref{['sec:rotSymmetric']}). After breaking the Fock states into generalized mod $N$ parity manifolds, the couplings in each manifold are tuned to achieve identical $\bar{X}(\theta)$ evolution in the codespace and all error subspaces. The solid colored arrows depict the couplings required for error-transparency to the errors $\hat{a}$ and $\hat{a}^{2}$, and the dotted arrow is the extra coupling required to achieve a full ET distance of $2$ (i.e. also ET to the no-jump error $\hat{n}$). We note that couplings between Fock states separated by an odd number of states within the generalized parity manifolds do not need to be used. This is a consequence of the Fock-space structure of rotation-symmetric codes and in general results in fewer required orders of squeezing to achieve a given ET distance.
• Figure 2: Parity nested gate performance.(a) Average gate infidelities, following recovery, of various parity nested $\bar{X}$ gates for the $N = 3$, $K = 3$ binomial code, subject to the pure photon-loss channel with total gate time $t = \frac{\pi}{2}$ and a range of error rates $\kappa$ (see Appendix \ref{['app:performance']}). The double squeezing (red), single squeezing (orange), and improved single squeezing (blue) gate Hamiltonians come from constructions 1, 2, and 3, respectively, outlined in Sec. \ref{['sec:performance']}. The table inset summarizes the ET properties and required squeezing orders of these three constructions. For comparison, the performance of a basic $\bar{X}$ gate (purple), generated by $H = |0_{L}\rangle\langle 1_{L}| + |1_{L}\rangle\langle 0_{L}|$, and idle evolution (gray) are also shown. As can be seen, the improved single squeezing gate essentially matches the scaling of idle evolution (and double squeezing) for large error rates, and yields a constant $8.6$ factor improvement over the single squeezing infidelity for smaller error rates. This constant factor is not generic, decreasing for larger gate times $t$ and increasing for larger binomial codes (see Appendix \ref{['app:performance']}). (b) Depiction of the time evolution in each of the error subspaces for the improved single squeezing gate. The solid lines show an example trajectory of the $|0_{L}\rangle$ state for one possible set of photon jump times.
• Figure 3: Larger binomial code performance. Repeat of performance plot (Fig. \ref{['fig:performance']}) for the (a)$N = K = 4$ and (b)$N = K = 5$ binomial codes. The double squeezing (red) Hamiltonian comes from Theorem \ref{['thm:SqueezingScaling']} with $l = 3$ (instead of $l = 2$), since these codes can accommodate three photon losses. The triple squeezing (dark orange) Hamiltonian comes from Theorem \ref{['thm:SqueezingScaling']} with $l = 4$, and is not shown for the $K = N = 4$ binomial code since it cannot accommodate four photon losses. We note that the improvement (relative to the $l = 1$ Theorem \ref{['thm:SqueezingScaling']} construction) of the improved single squeezing Theorem \ref{['thm:SingleSqueezing']} construction increases as the binomial code becomes larger, yielding a factor of $19$ improvement for the $N = K = 4$ code and a factor of $35$ improvement for the $N = K = 5$ code. The slopes for the $N = K = 5$ binomial code fidelity curves are computed only based on the $1 - e^{-\kappa t} < 0.05$ points.
• Figure 4: Parity nested gate in superconducting cavity. Implementation of the error-transparent gates on $N=K=2$ binomial code in a storage oscillator mode coupled to a qubit. Using an appropriate MEM comb on the qubit and driving the storage cavity for different duration we can accomplish error-transparent gates that can be used to create arbitrary superposition of the logical states with real coefficients. (a) and (b) respectively show the time evolution of the states in codespace and error space in the storage cavity. By driving the storage for the marked duration of 0.79$\epsilon^{-1}$, for both the error space and codespace, an error-transparent $\bar{X}$ gate can be accomplished. At the end of the gate we will need to detect errors by doing a parity check of the state in the storage cavity and then correct for any errors to accomplish the error-transparent gate. For these simulations the system was considered to be lossless and in the adiabatic limit with $\epsilon:\Omega:|\chi| = 0.01: 1: 100$.

Theorems & Definitions (11)

• Theorem 1
• Theorem 2
• Lemma 1
• proof
• proof
• proof
• Theorem 3
• Definition 1
• Lemma 2
• proof