Adaptive Window Decoding based on Spatiotemporal Complementary Gap

arXiv:2605.14637 · quant-ph · Submitted 2026-05-14 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Adaptive Window Decoding based on Spatiotemporal Complementary Gap".

Mira: The gist:

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So we’re looking at this paper now, "Adaptive Window Decoding based on Spatiotemporal Complementary Gap." It’s by Moeto Mishima and his team. This whole thing is about making real-time decoding faster without messing up the accuracy of the quantum computation.

Mira: Yeah, it tackles that core problem in window decoding where you want smaller windows for speed, but you have to keep a buffer size big enough to avoid errors one <ref:2605.14637#pg1>. They introduce a new way to measure confidence for this purpose.

Lev: From what I can tell on the hardware side, the real challenge is fitting this into actual decoder circuits that need to run very fast two <ref:2605.14637#pg1>. If the switching between small and large buffers takes too long, you’re back where you started with slow decoding.

Kai: Exactly. So what they propose is a two-step adaptive scheme where they first try decoding with a small buffer size and calculate some soft information about the decoder’s confidence. If that confidence score is low, it automatically enlarges the buffer size to the full code distance and does the decoding again two <ref:2605.14637#pg1>.

Mira: That sounds like they’re trying to be smart about when to spend time on a detailed decoding run versus just committing an estimate quickly two <ref:2605.14637#pg1>. It’s about dynamically adjusting based on how sure the decoder is.

Lev: The paper mentions that this switching aims to reduce average decoding time while keeping the logical error rate stable six. I need them to prove that this doesn't introduce new, unexpected error paths when they switch buffers two <ref:2605.14637#pg1>.

Kai: Okay, so they tackle the challenge that existing soft information isn't directly applicable to window decoding, especially with small buffers. They introduce something new called the spatiotemporal complementary gap for this setting five <ref:2605.14637#pg1>.

Mira: The spatiotemporal complementary gap sounds like a specific metric designed to look at the spatial and temporal structure of errors in a way that old methods couldn't handle ten <ref:2605.14637#pg1>. It’s analogous to the complementary gap idea, but tailored for windows eleven <ref:2605.14637#pg2>.

Lev: So how does this gap actually help? Is it just a better way to estimate the error chain? We need concrete proof that this new metric is robust enough for real-world surface codes three <ref:2605.14637#pg1>.

Title and authors: Kai: The spatiotemporal complementary gap is computed by first finding the minimum-weight error and then calculating a complementary error relative to some virtual boundaries and commit boundaries around that minimum weight thirteen <ref:2605.14637#pg2>. They modify the procedure, specifically closing the buffer boundary under certain conditions to get this spatiotemporal complementary gap, or STCG fifteen <ref:2605.14637#pg2>.

Mira: I’m interested in how they define that gap because it seems like the key ingredient for their adaptive switching mechanism two <ref:2605.14637#pg1>. It’s not just a calculation; it’s a condition that tells the system whether to switch buffer sizes two <ref:2605.14637#pg1>.

Lev: If we look at the distance-shifted STCG, they use an approximation for tmin, setting it equal to max(ceil(d/two) minus s, zero) seventeen. That means they’re trying to model the conditional logical error rate in a way that's manageable for their scheme nineteen.

Kai: And then they go further with the path-selected STCG. This version refines the gap definition by minimizing something like walt plus that tmin term with respect to the right and left boundaries, giving them this g value nineteen.

Mira: That path-selected version sounds like it’s trying to be super precise about how errors propagate across the graph, specifically looking at those boundary conditions nineteen. It’s a very fine-grained way to define that gap.

Lev: The results they show are interesting. They say the conditional logical error rate associated with this proposed gap decreases exponentially as the gap gets larger twenty-one. That suggests a strong relationship between how good their metric is and how low the final error rate is twenty-one.

Kai: And they show that this adaptive sliding window decoding scheme can achieve accuracy comparable to a global decoder, even at a switching rate of ten to the power of negative three with a buffer size of four for the repetition code twenty-two. That’s quite fast adaptation.

Mira: That comparison against the global decoder is important because it shows this adaptive approach isn't just slower; it maintains accuracy while being much faster in practice twenty-two. It validates their theoretical framework.

Lev: I also see them addressing extrapolation, which is crucial for hardware testing. They present a procedure to extrapolate data from high physical error rates down to the low-error-rate regime by assuming the conditional window-induced logical error rate stays the same with respect to the physical error rate twenty-one.

Kai: That extrapolation procedure relies on some assumptions, specifically that the conditional window-induced logical error rate is invariant with respect to the physical error rate and that different windows are independent twenty-one. That’s a big assumption they have to back up.

Title and authors: Mira: And I think what this whole paper means for us is that we don't necessarily need a fixed buffer size of 'd' for every window in practice ten <ref:2605.14637#pg1>. This work suggests the conventional idea that the buffer size must be exactly 'd' can be relaxed when you use a smart metric like the spatiotemporal complementary gap two <ref:2605.14637#pg1>.

Lev: For me, what this implies is that we can build hardware architectures where you have a fast, small-buffer decoder running on something efficient like an FPGA, and then a slower but more accurate strong decoder running on something more powerful like a CPU or GPU five <ref:2605.14637#pg1>.

Kai: Right. So in short, the paper "Adaptive Window Decoding based on Spatiotemporal Complementary Gap" shows how to make window decoding much faster by using a new soft information called the spatiotemporal complementary gap to switch buffer sizes adaptively, leading to about a forty percent reduction in average buffer size without losing logical error rate two.

Mira: It’s a solid piece of theory that gives us a practical tool for improving reaction time during non-Clifford gate operations twenty-two. It moves the conversation away from rigid buffer sizes toward dynamic, confidence-based decisions ten <ref:2605.14637#pg1>.

Lev: We still need to see how well this actually translates when we put it on real, noisy hardware. The extrapolation procedure is a good start, but simulating those error rate assumptions will be key for us twenty-one.

Kai: So the spatiotemporal complementary gap is the mechanism that lets the system decide when to go big and when to go small based on its confidence score two <ref:2605.14637#pg1>. It’s about making window decoding more flexible and less wasteful of time.

Mira: It’s a very focused contribution because it directly solves the applicability problem of soft information in this specific setting, which is a real hurdle for anyone trying to implement these schemes eleven <ref:2605.14637#pg2>.

Lev: And the path-selected STCG seems like the most promising part for making those switching decisions really effective because it optimizes that error chain calculation nineteen.

Kai: So, we've covered how this paper aims to reduce average buffer size by approximately forty percent while maintaining the logical error rate using its adaptive window decoding scheme two. We’re going to take a quick break and then talk about some of those other papers that are out there.

The paper's summary: Kai: So, we've seen how they’re using this new spatiotemporal complementary gap to switch buffer sizes automatically, which cuts down on average buffer size by about forty percent while keeping the logical error rate stable.

Mira: What that really means is that instead of having a fixed buffer size that might be too big for some parts of the decoding graph and too small for others, this system gets smarter about when to use a bigger look-ahead window and when to stick with a smaller one.

Lev: From what I see, it’s about making the whole decoding process more dynamic, responding directly to the current confidence level of the estimate rather than just following a rigid schedule.

Kai: Exactly. It moves away from that 'set it and forget it' approach in window decoding and makes sense for real-time operation where things aren't perfectly uniform.

Mira: The authors are really focused on how they create that spatiotemporal complementary gap, which is this new piece of soft information specifically built for these windowed problems. It’s their way of telling the decoder what it *should* be confident about at any given spot on the lattice.

Lev: And they show that this specific metric works well, leading to an exponential decrease in error rate as the gap gets bigger, which is a pretty strong result for error tolerance.

Kai: It’s not just about reducing processing time; it's fundamentally changing how we manage the trade-off between speed and accuracy in these surface code decoding tasks.

Mira: And then they show that this adaptive sliding window scheme can actually match the accuracy of a standard global decoder when you set the switching rate to something like ten to the power of negative three with a buffer size of four for a repetition code. That’s a pretty good comparison.

Lev: That comparison is key because it shows that this isn't just some theoretical tweak; it performs comparably in terms of actual logical error rates under specific conditions.

Kai: It suggests that the idea that you *must* fix your buffer size at something like the code distance is too rigid, and this paper shows how to relax that rule in practice.

Mira: And they’re not just stopping there either; they’ve included a procedure for extrapolating results from high physical error rates down to lower ones, which is important because you can't always run simulations at those very low error regimes.

Lev: That extrapolation relies on assumptions about how the window errors behave when the physical noise level changes, so it’s an interesting way to predict performance without having to do a ton of expensive Monte Carlo work for every possible error rate.

Kai: So, what this paper really offers is a concrete mechanism—the spatiotemporal complementary gap—to make window decoding more flexible and less wasteful of time in the context of fault-tolerant quantum computing.

Mira: It’s about giving the decoder a better internal gauge to decide when to spend more time verifying its results versus when to move on quickly, all while keeping the logical errors under control.

Lev: And that flexibility is exactly what you need for scalable real-time decoding in future quantum hardware platforms.

The paper's improvements: Kai: So, we've seen how they use that new spatiotemporal complementary gap to make buffer size adjustments automatically, which cuts down on average buffer size by about forty percent while keeping the logical error rate stable.

Mira: What that really means is that instead of having a fixed buffer size that might be too big for some parts of the decoding graph and too small for others, this system gets smarter about when to use a bigger look-ahead window and when to stick with a smaller one.

Lev: From what I see, it’s about making the whole decoding process more dynamic, responding directly to the current confidence level of the estimate rather than just following a rigid schedule.

Kai: Exactly. It moves away from that 'set it and forget it' approach in window decoding and makes sense for real-time operation where things aren't perfectly uniform.

Mira: The authors are really focused on how they create that spatiotemporal complementary gap, which is this new piece of soft information specifically built for these windowed problems. It’s their way of telling the decoder what it *should* be confident about at any given spot on the lattice.

Lev: And they show that this specific metric works well, leading to an exponential decrease in error rate as the gap gets bigger, which is a pretty strong result for error tolerance.

Kai: It’s not just about reducing processing time; it's fundamentally changing how we manage the trade-off between speed and accuracy in these surface code decoding tasks.

Mira: And they also introduce distance-shifted and path-selected versions of this gap, which are basically more refined ways to calculate that error chain, aiming for a better switching criterion.

Lev: The path-selected version minimizes some specific error terms with respect to the boundaries, which means they’re trying to get a much more precise definition of what constitutes a good gap when deciding whether to switch buffers.

Kai: So these refinements mean that the decision to switch buffer sizes isn't just based on one simple confidence score anymore, it’s based on this more detailed look at how errors propagate through the graph.

Mira: And they also have this procedure for extrapolating performance at lower physical error rates by assuming certain conditions hold true about the conditional window-induced logical error rate.

Lev: That extrapolation relies on assumptions about how the window errors behave when the physical noise level changes, so it’s an interesting way to predict performance without having to do a ton of expensive Monte Carlo work for every possible error rate.

Kai: It suggests that we can build hardware architectures where you have a fast, small-buffer decoder running on something efficient like an FPGA, and then a slower but more accurate strong decoder running on something more powerful like a CPU or GPU.

Mira: That's the big picture here—it’s about creating a system that uses different resources depending on the actual computational needs of that specific part of the decoding task.

Lev: This approach is directly applicable to improving reaction time during non-Clifford gate operations, which is where we often need to speed up things in real quantum experiments.

Kai: So, what this paper really offers is a concrete mechanism—the spatiotemporal complementary gap—to make window decoding more flexible and less wasteful of time in the context of fault-tolerant quantum computing.

Mira: It’s about giving the decoder a better internal gauge to decide when to spend more time verifying its results versus when to move on quickly, all while keeping the logical errors under control.

Lev: And that flexibility is exactly what you need for scalable real-time decoding in future quantum hardware platforms.

Conclusion: Kai: So, to wrap up on "Adaptive Window Decoding based on Spatiotemporal Complementary Gap," this paper shows how we can make window decoding much faster by using that new soft information to switch buffer sizes automatically, which cuts down on average buffer size by about forty percent while keeping the logical error rate stable.

Mira: It's about giving the decoder a better internal gauge to decide when to spend more time verifying its results versus when to move on quickly, all while keeping the logical errors under control.

Lev: And that flexibility is exactly what you need for scalable real-time decoding in future quantum hardware platforms.

Kai: It suggests that we can relax the idea that you *must* fix your buffer size at something like the code distance for every window in practice.

Mira: And they're not just stopping there either; they've included a procedure for extrapolating performance at lower physical error rates by assuming certain conditions hold true about the conditional window-induced logical error rate.

Lev: That extrapolation relies on assumptions about how the window errors behave when the physical noise level changes, so it’s an interesting way to predict performance without having to do a ton of expensive Monte Carlo work for every possible error rate.

Kai: So, what this paper really offers is a concrete mechanism—the spatiotemporal complementary gap—to make window decoding more flexible and less wasteful of time in the context of fault-tolerant quantum computing.

Mira: It’s about giving the decoder a better internal gauge to decide when to spend more time verifying its results versus when to move on quickly, all while keeping the logical errors under control.

Lev: This path-selected version of the gap seems like it’s the most promising part for making those switching decisions really effective because it optimizes that error chain calculation.

Kai: So, we've seen how this method successfully reduces average decoding time while preserving the logical error rate using a small buffer size, and it is applicable to improving reaction time during non-Clifford gate execution.

Mira: It’s a solid piece of theory that gives us a practical tool for improving reaction time during non-Clifford gate operations.

Lev: I just want to say that the extrapolation procedure is important because it shows how we can get predictions down to lower error regimes, which is what you need for real hardware testing.

Quantum Laboratory, Fujitsu Research, Fujitsu Limited · Fujitsu Quantum Computing Joint Research Division, Center for Quantum Information and Quantum Biology, The University of Osaka · Graduate School of Engineering Science, The University of Osaka · Graduate School of Informatics, Kyoto University · RIKEN Center for Quantum Computing (RQC)

quant-ph

Submitted: 2026-05-14

Updated: 2026-10-09

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 74/100

The gist: The gist: The proposed method reduces average buffer size by approximately 40 % while maintaining the logical error rate in window decoding by introducing a new form of soft information called the

Key concepts

Window Decoding
This technique breaks down a large quantum error-correction problem into smaller, manageable sections called windows. Instead of solving the entire problem at once, the decoder solves smaller matching problems within each window to piece together a final global solution.
Buffer Region
Each window in decoding has a buffer region that helps improve the accuracy of the local error estimate within that window. This buffer must be large enough—typically at least as large as the code distance ($d$)—to prevent logical errors from increasing, but this size limits how small the windows can become.
Spatiotemporal Complementary Gap (STCG)
This is a novel form of soft information designed specifically for window decoding. It is calculated by comparing minimum-weight errors with virtual boundaries to estimate conditional logical error rates. Using this gap allows the scheme to adaptively adjust buffer sizes based on decoding confidence.

Terminology

Summary

The gist: The proposed method reduces average buffer size by approximately 40 % while maintaining the logical error rate in window decoding by introducing a new form of soft information called the spatiotemporal complementary gap.

Background and Motivation

Real-time decoding plays a crucial role in practical fault-tolerant quantum computing, as slow decoding directly slows down the quantum computation itself <ref:2605.14637#pg2>. Window decoding is an approach where the decoding problem is divided into windows to accelerate processing <ref:2605.14637#pg3>. A central challenge in realizing this scheme is that existing forms of soft information are not directly applicable to window decoding, especially with a small buffer <ref:2605.14637#pg4>. The paper addresses this by introducing a new form of soft information, the spatiotemporal complementary gap, specifically designed for this setting <ref:2605.14637#pg5>. Numerical simulations demonstrate that the proposed scheme reduces the average buffer size by approximately 40 % while maintaining the logical error rate <ref:2605.14637#pg6>.

Adaptive Window Decoding Scheme

The proposed adaptive decoding scheme involves a two-step process to reduce average decoding time while preventing degradation of the logical error rate <ref:2605.14637#pg7>.

  1. First, decoding is performed with a small buffer size and a decoding confidence (soft information) is computed <ref:2605.14637#pg8>.

  2. If the confidence is low, i.e., smaller than a predetermined threshold gth, the buffer size is enlarged to d and decoding is redone <ref:2605.14637#pg9>.

Soft Information in Window Decoding

The paper introduces three new types of soft information tailored to this setting: the spatiotemporal complementary gap (STCG), the distance-shifted STCG, and the pathselected STCG <ref:2605.14637#pg10>. The core idea is analogous to that of the complementary gap, focusing on minimum weight while neglecting degeneracies and higher-order terms <ref:2605.14637#pg11>.

Spatiotemporal Complementary Gap (STCG)

The STCG is computed by first computing the minimum-weight error Emin and then computing the complementary error Ecomp with respect to the virtual boundary and commit boundary relative to Emin <ref:2605.14637#pg13>. The procedure involves several modifications, including closing the buffer boundary under specific conditions to obtain a gap, which is referred to as the Spatiotemporal complementary gap (STCG) <ref:2605.14637#pg15>.

Distance-Shifted STCG and Path-Selected STCG

To approximate the conditional logical error rate, distance-shifted STCG is introduced by approximating tmin using tmin = max(⌈d/2⌉−s, 0) <ref:2605.14637#pg17>. The path-selected STCG further refines this by minimizing walt + max(⌈d/2⌉ − s, 0) with respect to the right and left boundaries, yielding g:= min(w'alt,R, w'alt,L) − wmin <ref:2605.14637#pg19>.

Performance and Applications

Numerical results show that the conditional logical error rate associated with the proposed gap decreases exponentially with the gap <ref:2605.14637#pg21>. The adaptive sliding window decoding based on these gaps achieves comparable accuracy as the global decoder at a switching rate of 10−3 with rbuf = 4 for the repetition code <ref:2605.14637#pg22>. The method is also applicable to improving reaction time during non-Clifford gate operations and switching across distinct hardware platforms.

Extrapolation to Low Physical Error Rates

A procedure is presented for extrapolating data obtained at high physical error rates to the low-error-rate regime, focusing on the path-selected STCG. This procedure relies on assumptions such as the conditional windowinduced logical error rate being invariant with respect to the physical error rate and independence between windows.

Conclusion

The proposed method successfully reduces average decoding time while preserving the logical error rate using a small buffer size, and it is applicable to improving reaction time during non-Clifford gate execution. The work suggests that the conventional view—that the buffer size must be fixed at approximately d—can be relaxed in practice. The proposed method is particularly well-suited to fault-tolerant quantum computation in which scalable real-time decoding is required.

--- Page 1 ---

Adaptive Window Decoding based on Spatiotemporal Complementary Gap Moeto Mishima,1, 2, ∗ Riki Toshio,1, 2 Kaito Kishi,1, 2 Jun Fujisaki,1, 2 Hirotaka Oshima,1, 2 Shintaro Sato,1, Keisuke Fujii2,3,4,5 Quantum Laboratory <ref:2605.14637#pg8> Real-time decoding plays a crucial role in practical fault-tolerant quantum computing. Window decoding, in which the decoding problem is divided into windows, is a promising approach <ref:2605.14637#pg9>. While reducing the window size is desirable for faster decoding, each window contains a buffer region whose size must typically be at least the code distance to avoid degrading the logical error rate, which limits how much the window can shrink <ref:2605.14637#pg10>. In this paper, we propose an adaptive decoding scheme in which window decoding is first performed with a small buffer size and a decoding confidence (soft information) is computed; if the confidence is low, the buffer size is enlarged and decoding is redone <ref:2605.14637#pg9>. This approach reduces the average decoding time, since most shots are decoded with a small buffer <ref:2605.14637#pg10>. A central challenge in realizing this scheme is that existing forms of soft information are not directly applicable to window decoding, especially with a small buffer <ref:2605.14637#pg11>. We address this challenge by introducing a new form of soft information, the spatiotemporal complementary gap, specifically designed for this setting <ref:2605.14637#pg12>. Numerical simulations demonstrate that the proposed scheme reduces the average buffer size by approximately 40 % while maintaining the logical error rate <ref:2605.14637#pg13>.

I. INTRODUCTION Fault-tolerant quantum computing (FTQC) is essential for performing large-scale quantum computations reliably, since physical qubits and quantum operations are inevitably subject to noise <ref:2605.14637#pg2>. Among the many quantum error-correcting codes proposed for realizing FTQC, the surface code has attracted particular attention due to its compatibility with two-dimensional qubit layouts, such as those of superconducting qubits, and its high threshold [1–8] <ref:2605.14637#pg2>. A fast and accurate decoder is one of the key requirements for FTQC, especially in platforms with fast gate operations such as superconducting qubits [9, 10] <ref:2605.14637#pg3>. Decoding is the process of inferring the underlying physical errors from the syndrome measurement outcomes, which provide indirect information about the errors <ref:2605.14637#pg3>. If the decoder is inaccurate, the logical error rate of the encoded qubits becomes unacceptably high, and the result of the computation can no longer be trusted <ref:2605.14637#pg4>. Decoding speed is equally important: in particular, non-Clifford gates cannot be executed until decoding has been completed up to the corresponding point in the circuit, so slow decoding directly slows down the quantum computation itself <ref:2605.14637#pg5>. If, moreover, the average decoding speed cannot keep up with the rate at which syndrome measurements are produced, the so-called backlog problem arises and the computation time grows exponentially [1pg2]. Even when the decoder is fast enough on average to avoid this issue, faster decoding remains desirable, as it reduces the idle time required before each non-Clifford gate <ref:2605.14637#pg6>.

One approach to accelerating decoding is window decoding <ref:2605.14637#pg7>. Decoding the surface code reduces to solving a matching problem on a three-dimensional cubic-lattice decoding graph, and the time required to solve this matching problem grows rapidly with the size of the graph <ref:2605.14637#pg8>. In window decoding, the decoding graph is divided into smaller subgraphs called windows, and matching is performed within each window to assemble a global solution <ref:2605.14637#pg9>. Two main variants of window decoding exist. Sliding window decoding processes windows sequentially as the window slides along the decoding graph [3] <ref:2605.14637#pg2>. Parallel window decoding places multiple windows over the decoding graph and processes them in parallel [12–14] <ref:2605.14637#pg3>. A number of refinements and extensions have been studied, including spatial window partitioning for lattice surgery [15], distributed decoding across multiple FPGAs [16], speculation-based prediction of inter-window dependencies to reduce reaction time [17], and a method that eliminates the overhead due to window overlap [18] <ref:2605.14637#pg4>.

While window decoding accelerates decoding by splitting a large problem into smaller, possibly parallelizable subproblems, the windows cannot be made arbitrarily small <ref:2605.14637#pg5>. Each window consists of two regions: a commit region, whose local decoding result is adopted as the final error estimate, and a buffer region, which serves to improve the accuracy of the estimate within the commit region <ref:2605.14637#pg6>. It is known that if the buffer region is too small, the estimation accuracy degrades significantly, while a buffer region of width approximately d along the decoding graph (where d is the code distance) suffices to reproarXiv:2605.14637v1 [quant-ph] 14 May 2026

--- Page 2 ---

FIG. 1. Schematic of the adaptive window decoding scheme <ref:2605.14637#pg2>.

Improvements for AI systems

  1. Bold header: Adaptive Window Decoding Implementation

This system can reduce average decoding time by performing decoding with a small buffer size and a decoding confidence (soft information) is computed; if the confidence is low, the buffer size is enlarged and decoding is redone. This leads to an estimated reduction in average buffer size by approximately 40 % while maintaining the logical error rate.

  1. Bold header: Spatiotemporal Complementary Gap Integration

The system can compute a novel soft information called spatiotemporal complementary gap (STCG), which is specifically designed for window decoding. This allows the system to switch between small and large buffer sizes based on this new metric, reducing the average buffer size by approximately 40% while maintaining the logical error rate.

  1. Bold header: Path-Selected Gap Optimization

The system can utilize path-selected STCG to compute an error chain that approximately minimizes walt + max(⌈d/2 − s, 0) with respect to the right boundary, leading to a gap definition that is expected to be more effective as a switching criterion.

  1. Bold header: Low Physical Error Rate Extrapolation

The system can implement a procedure for extrapolating performance at low physical error rates by assuming the conditional window-induced logical error rate is invariant with respect to the physical error rate, allowing prediction of performance in the fault-tolerant operating regime without direct Monte Carlo simulation.

  1. Bold header: Hardware Platform Switching Architecture

The system can realize an architecture analogous to the weak/strong decoder framework, where a "window decoder with a small buffer runs on fast and resource-efficient hardware such as FPGAs or ASICs, while the strong decoder, a window decoder with a buffer of size d (optionally employing a more accurate inner decoder), runs on a CPU or GPU."

Sources

Related papers