Quantum state preparation and oracles got cheaper at QCE26, on paper

This guide follows 18 talks on the standard parts inside quantum algorithms at IEEE Quantum Week 2026 in Toronto. Gate counts fell, sometimes sharply, and nearly all of it happened in proofs, simulations and counts.

On the Sunday morning of IEEE Quantum Week 2026, in Room 713B of the Metro Toronto Convention Centre, a paper from Fujitsu made a quantum circuit cheaper by doing something any filing clerk could do. Yusuke Kimura and Yutaka Takita shuffled the rows of a table before any circuit was built. In their worked example, the circuit that looks those rows up came out with half its Toffoli gates, the most expensive kind it used. The talk was about lookup tables, yet the same move ran through the week’s work on oracles, arithmetic and quantum state preparation, the step that loads data into a quantum computer. Most of the savings were bought on an ordinary computer before the quantum one was switched on.

The famous quantum algorithms are built from a short list of standard parts. The first is quantum state preparation, which loads numbers into the amplitudes of a set of qubits, the weights whose squares give the chance of each outcome. The second is the oracle, a circuit that tests each input and marks the ones that pass. Lov Grover’s search of 1996 is built around such an oracle. Peter Shor’s factoring method of 1994 spends most of its gates on the third part, arithmetic, which a quantum computer must do with steps that can run backwards. A fourth part, the block encoding, hides a matrix inside a larger quantum operation so the machine can apply it.

Every part has a price, paid mostly in gates. On today’s noisy chips two-qubit gates fail most often, so people count them, usually as CNOTs. On a future error-corrected machine the costly ones are the T gate and the three-qubit Toffoli built from it. Each needs a special resource called a magic state, and the factories that make those states could fill much of the machine, which is why papers aimed at error-corrected machines report T counts first. Loading data is the dearest item of all. A list of a million numbers fits into just 20 qubits, yet writing a typical list in takes about a million gates.

The 18 talks followed here, from the conference also known as QCE26, cut those prices, and together they support a claim a sensible reader could dispute. The building blocks are getting cheaper mainly because classical computers do more of the work before the circuit runs, and a gate count says little about speed until someone sets a quantum clock beside a classical one. Classical work done once in advance is fair play. It becomes a problem only when it grows as fast as the problem the circuit was meant to speed up.

The best reply is that gates are the right measure. On most designs for an error-corrected machine, T gates and Toffolis dominate the bill, so halving them goes a long way toward halving the cost of the part. A team from the Singapore Institute of Technology and National Cheng Kung University made that case on the Thursday, cutting a four-bit counter from 20 T gates to 12. Iain Burge, in the same session, built a reversible arcsine from fewer than 14n additions. A part that runs many times inside a larger program repays every gate it saves, and that argument is sound as far as it goes.

Look at where the savings came from, though. Kimura and Takita find their row order with simulated annealing on a laptop. The circuit comes later. Debora Ramacciotti and their co-authors cut the CNOTs in a quantum state preparation circuit about a thousandfold for very sparse states, by merging rotations in a classical pass. David Quiroga’s Qvine circuit for market data rests on a statistical model fitted on an ordinary computer. On the Friday, Amit Surana of RTX cut the number of terms in a matrix sum by building the matrix from pieces chosen in advance. In every case the circuit shrank because work moved off the quantum machine and onto a classical one.

Yet a cheaper part is still only a part. The harder question is about time. Nishant Shukla of QA Wolf spent two Sunday sessions on a game-playing oracle and gave a blunt rule for judging it. Against 1,000 classical cores, Shukla said, one quantum call must run about a hundred times faster than one classical rollout, a random play-through of the game, before the quantum version wins.

Nicholas Zhao of Imperial College London proved a square-root gain in one cost of sampling and then showed it shrank to a constant in the case Zhao cared about. On the Tuesday, Simone Perriello of Politecnico di Milano found that a faster quantum walk still loses to plain Grover diffusion until problems grow very large. None of the 18 talks timed a full building block on hardware against a classical rival. Every saving in this guide is still a saving on paper.

Loading data with quantum state preparation

Quantum state preparation builds a chosen state from qubits that all start at zero. One presenter called it part of every quantum algorithm, and it often decides whether a promised speed-up survives the trip from paper to machine. Four talks attacked it. Two of them leaned on a classical pass done in advance, a third rebuilt the quantum routine itself, and a fourth built graph states.

Merging rotations cuts sparse loading a thousandfold

Debora Ramacciotti’s team cut the cost of loading sparse states about a thousandfold. One of their co-authors gave the talk in their absence. The paper is by Ramacciotti with Martin Steinbach, Bence Temesi, Andreea Iulia Lefterovici and Antonio Rotundo. It builds on the Grover-Rudolph method, which splits the probability down a tree of turns, each one set by the qubits above it, with one angle for every pattern.

Sparse states, where most entries are zero, leave many of those angles at zero. Two neighbouring turns that share an angle can then merge into one with a control removed, and each merge saves CNOTs. A second move copies an angle into an empty branch to set up another merge, and a looser version also merges angles that are merely close, while keeping the loss within a fixed bound.

On 20 qubits a plain loader needs about a million CNOTs. For states with roughly one nonzero entry in a thousand or fewer, the exact merges cut that by about a thousand times. Denser than that, the presenter said, the method stops being worth using. The approximate merges removed at most about 35 percent more on random test states. Asked from the floor whether this was classical work shrinking the circuit in advance, the presenter at first said it was more than that, and when pressed agreed that it basically was.

One working qubit for sampling from a Markov chain

Nicholas Zhao of Imperial College London cut the working register for a sampling task from many qubits to one. Zhao wrote the paper alone. Their target is a QSample, a state whose amplitudes are the square roots of a list of probabilities, so that measuring it gives a fair sample and the state itself can feed other quantum routines. The usual route needs a working register that grows as the answer must get more precise.

Zhao swaps phase estimation for a polynomial filter that keeps only the target state and needs one extra qubit. Zhao wraps it in a fixed-point search published by Yoder, Low and Chuang in 2014. Against an older method from 2008, their query count grows with one over the square root of the overlap between steps, where theirs grows with one over the overlap. That is a real gain on paper.

The theorem needs four things. The chain must be reversible and change slowly, the starting state must be exact, and an oracle must supply the transitions. When the overlap is a constant, as in the Gibbs case Zhao studied, the saving shrinks to a constant factor. The only numerical check was a tiny 2 by 4 Ising ladder, where the error stayed inside their bound.

Qvine loads stock-market data one pair at a time

David Quiroga, a recent Rice University graduate, showed a circuit that loads the joint behaviour of several stock prices. Quiroga wrote the paper with Hannes Leipold and Bibhas Adhikari. The task is to load a distribution over many variables, such as the returns of AMD, NVIDIA and the S&P 500, so a model can draw new price paths. A vine copula, a statistical model, builds such a distribution from pairs of variables, and Qvine turns each layer of pairs into rings of rotation gates.

Each variable gets three qubits, which give eight bins. For three assets on nine qubits, the gap between the loaded and target distributions fell from 0.0693 to 0.0188 by total variation distance, the largest difference in probability the two can show on any event. For four assets on 12 qubits, the AMD and NVIDIA slice fell from 0.0664 to 0.0374.

Quiroga named the qubit count as the main limit. At three qubits each, Quiroga said, a hundred variables are out of reach. Leipold, answering a question from the floor, said the classical vine is itself only an approximation, and that the team cannot yet say which kinds of distribution it misses. All the numbers come from exact simulation.

A qubit’s entanglement tracks its vertex’s degree

Khrystyna Gnatenko of SoftServe and Ivan Franko National University of Lviv built graph states for tripartite graphs. A graph state gives each point of a graph one qubit and turns each edge into an entangling step, so the shape of the graph is written into the state. In a tripartite graph the points fall into three groups. Edges run only between groups.

Gnatenko used three kinds of two-qubit turn as the edges. Gnatenko said that when the graph is unweighted, the entanglement of a qubit tracks the degree of its point, the number of edges that meet there, and a quantum correlator tracks the number of closed loops of four edges.

The check was small. It was a triangle, which Gnatenko called the simplest tripartite graph, with exact results set beside points from Qiskit’s AerSimulator, and the gaps between the two ran from 0.1009 to minus 0.1224 at one setting.

Oracles and lookup tables

An oracle is the part of a search that spots a right answer. If it is slow or wide, a search that needs fewer queries can still lose on the clock, which is why five talks set out to price or build one. Fujitsu shrank a lookup table, Nishant Shukla built a whole game oracle in code across three sessions, and a team from Hagenberg and Linz generated oracles from plain rules.

Reordering a table halves its Toffoli gates

Yusuke Kimura and Yutaka Takita of Fujitsu showed that the order of rows in a table changes the cost of the circuit that stores it. A Grover search over a table needs a QROM, a circuit that writes a row’s data when given its address. The logic for each output bit is first simplified with a long-established classical tool, and each simplified term becomes one controlled gate. Addresses carry no meaning of their own. That frees the rows to be shuffled before the circuit is built, and a classical table maps the answer back afterwards.

In the worked example the first order built 7 gates, four of them Toffolis. Swapping two rows gave 6 gates with just two Toffolis. Trying every order is hopeless past tiny tables, so the method scores each order by a quick stand-in and runs simulated annealing, a classical search, over about 1,000 swaps on a laptop. The Fujitsu presenter said the search itself is not new.

At 8 rows the team scored all 40,320 orders, and a bad order cost about twice a good one. The stand-in tracked the true T count closely. From 16 to 128 rows annealing beat random search at every size, though both drifted toward no gain on a fixed budget of 1,000 trials, because the number of orders grows and the budget does not. The presenter’s advice was to let it run. The trick works only when an address means nothing in itself.

When is a quantum oracle worth building at all

Nishant Shukla of QA Wolf spent their first tutorial session asking whether a quantum oracle for game playing is worth building. A rollout plays a game forward at random to judge a move. A quantum method called amplitude estimation needs about one over the gap between two moves to tell them apart, while classical sampling needs about one over the gap squared. That square-root saving is the whole prize.

Their first test is whether sampling is needed at all. The dice game Pig fails it, since its 505,000 positions were solved exactly in 2004. Their second test compares running times. With a thousand classical cores, an overhead of 10 and a gap of 0.01, one quantum call must run about a hundred times faster than one classical rollout to win. Shukla cited Ewin Tang’s 2018 classical answer to a quantum recommendation algorithm as a warning about weak baselines.

Shukla then introduced Sway, a board game with dice in which a stone is more likely to flip the fewer friendly neighbours it has. Against a large classical run, a 1 millisecond quantum call looks fine. At 10 milliseconds the classical side can tie it. At 100 the classical side wins.

Building the Sway oracle in Qiskit

In their second session Shukla built the Sway oracle in Python and Qiskit, for an empty 3 by 3 board played two rounds ahead. One call loads the dice, plays the moves and the random flips, and writes a payoff of 1 if black wins. It took 169 qubits. The benchmark reported 9,768 gates for one forward call, and undoing that call afterwards, which the method requires, costs about the same again.

Every scratch qubit must come back clean, Shukla stressed. A qubit left holding a result stays linked to the answer and spoils the interference the method needs to work. Their scaling table reached 25,189 qubits and about 6.1 million gates for a 20 by 20 board ten rounds ahead, and that was before adding any error correction at all.

Shukla was frank about the limit of the gain, which is only quadratic. The square root of an exponentially large game tree, Shukla said, is still exponentially large, so in their view AlphaGo and AlphaZero stay classical. The code is on GitHub.

The same recipe fits an epidemic model

Nishant Shukla came back on the Tuesday with a paper, written alone, on how to build such oracles in general. The task is to pick the best of K actions. Their payouts are unknown. A quantum bound by Wang and others grows as the square root of K over epsilon, the allowed shortfall, against a classical floor of K over epsilon squared. It assumes a coherent rollout, a reversible circuit that plays a whole game forward in superposition, and the paper builds one.

The circuit picks a legal move, plays it, scores the result and repeats out to the horizon. Shukla mapped Sway onto a model of how a disease spreads, down to where to put vaccine centres, and onto forest fires. At the largest size, a 20 by 20 board ten moves deep, the disease version needed 21,409 qubits and about 2.6 million gates, before any fault-tolerant overhead. Shukla called that scale out of reach. Only the smallest boards were simulated.

Grover oracles generated from plain rules

Bernhard Schenkenfelder of the Software Competence Center Hagenberg presented work with Christoph Stein, Stefan Klikovits and Manuel Wimmer of Johannes Kepler University Linz. Grover search can solve a puzzle only if someone builds an oracle that marks the right answers. That is hard work. In their language, users just state the variables and the rules, and the compiler turns the variables into qubits and the rules into steps that clean up their own spare qubits.

The second tool, gospl, lets users cap the number of helper qubits by grouping rules into batches. That fits a problem onto fewer qubits, at the cost of sometimes marking answers that meet only some of the rules. On graph colouring and 4 by 4 Sudoku, run over 100,000 shots in Qiskit Aer, success rose as helper qubits were added, while the depth of the oracle fell. Schenkenfelder could not say how the method scales.

Reversible arithmetic, priced in T gates

Quantum arithmetic has to run both ways, so every scratch result must be undone at the end. Two papers in one Thursday session built arithmetic circuits and counted their costly steps with care, one in T gates and the other in additions. A third used CORDIC.

A four-bit counter drops from 20 T gates to 12

A team from the Singapore Institute of Technology and National Cheng Kung University cut a four-bit leading-zero counter from 20 T gates to 12. The authors are Lei-Han Yao, Shang-Wei Lin, Yu-Chung Chen and Yean-Ru Chen. Such a counter finds where the first 1 sits in a binary number, which is the step that tidies a floating-point number, the way computers store fractions and very big numbers, and sets its size.

Their design, TA-OP, uses a cheaper stand-in for the Toffoli that Craig Gidney published in 2018. It costs 4 T gates instead of 7. One shared core counts ones or zeros by flipping the inputs. A step-by-step form keeps the costs growing in line with the number of bits, and a parallel form cuts the T depth further at the price of more spare qubits.

Against a 2023 circuit by Orts and colleagues, the four-bit version cut T count from 20 to 12 and T depth from 10 to 4, with one fewer qubit. Widths from 11 to 32 bits matched classical results in both modes. The team said its circuit beats the earlier one on every metric it measured.

An arcsine on a budget

Iain Burge built a reversible arcsine that fits in 5n qubits plus a constant and uses fewer than 14n additions. Burge is at Institut Polytechnique de Paris, and wrote the paper with Joaquin Garcia-Alfaro of the same school and Michel Barbeau of Carleton University. The arcsine turns a stored number into an angle. That lets the number be written into an amplitude, which is a step that the HHL method for solving systems of linear equations needs.

The circuit adapts CORDIC, a method from the late 1950s. It builds an angle from a fixed list of small turns, and two copies of a tiny turn stretch a vector by a known amount, which Burge uses in place of a costly division. In tests the mean error was 0.327 at four bits and 0.0991 at six, matching a classical twin of the same circuit.

A hard error bound is not yet in this version of the paper. A questioner from the floor said HHL would need one, and pointed to earlier work on a different method from about ten years before. Rounding errors can also build up inside each multiply step.

CORDIC turns for a quantum renderer

Doron Gordon, a high-school student from Bloomington, Indiana, presented a paper with Goren Gordon on ray marching, a way to draw a scene. A ray advances in steps, guided by a signed distance to the nearest surface. When it hits one it scatters in a random new direction. So the colour of a pixel is an average over many random paths, and averaging q paths on a classical machine leaves an error of one over the square root of q.

Gordon swaps that average for quantum mean estimation, which reaches one over q, and uses CORDIC turns to send the ray off each surface. The claimed cost was 110 qubits for a scene with 2 to the 10 cells on each axis. No device run was shown.

Block encodings and loading matrices

Many newer algorithms work on a matrix that is not itself a quantum operation. A block encoding places a scaled copy of it in one corner of a larger operation that is. Three talks priced that step, one by comparing whole simulation methods and two, in a Friday tutorial, by writing the matrix down so that it costs fewer terms to load.

Block encoding wins the gate count for the SYK model

Brian Goldsmith showed that a block encoding needs far fewer T gates than two simpler methods for simulating the SYK model. Goldsmith wrote the paper with Larissa Kroell and Nishna Aerabati for the Quantum Open Source Foundation. The model links particles four at a time with random strengths. Goldsmith tied it to the physics of black holes, and set a product formula, which applies each part of the energy in small steps, against a random-sampling method called qDRIFT and a block encoding.

The counts came from PsiQuantum’s Workbench tool. A public repository repeats them. At 100 modes the block encoding stayed under 500 million T gates, qDRIFT passed 4 billion, and the product formula ran off the top of the chart after just eight modes, far above both of its rivals.

The trade-off was in qubits. qDRIFT used fewer of them, while the block encoding paid for its lower gate count with a wider register of qubits. A tighter error target barely moved its cost. Goldsmith said the project is now finished.

Writing a matrix with far fewer terms

A tutorial group from the US Naval Research Laboratory and RTX showed how to write a matrix as a sum of far fewer terms. Reuben Demirdjian of the lab opened, and Amit Surana of RTX gave the theory. The programme also lists Abeynaya Gnanasekaran of IonQ and Thomas Hogancamp of the Naval Research Laboratory. Solvers in the HHL family are fast only if the matrix can be loaded. The usual way writes it as a sum of Pauli strings, which are simple products of one-qubit steps, and for a matrix from a differential equation that sum can be as long as the matrix.

The group’s method, LCNU, builds the matrix from four simple 2 by 2 pieces that each hold a single 1. The number of terms never exceeds the number of nonzero entries. For a one-dimensional Poisson equation, a standard test, the Pauli count grows about in line with the number of grid points, while the new count grows only with its logarithm. That is an exponential cut in terms.

These pieces are not valid quantum operations, so each one is completed with an extra gate, and a run counts only when one helper qubit reads a set value. Another presenter then built a heat equation this way, with one multi-controlled gate per term, and matched the arithmetic in a notebook. The general case was left for the afternoon.

When one gate is enough

Thomas Hogancamp of the Naval Research Laboratory took the afternoon. The talk showed how to block encode a matrix that is a product of simple factors, such as Pauli matrices, blocks with one entry and permutations, which reorder the entries. Each factor is completed on its own. The results are then multiplied, with any factor that is already a quantum operation left on the outside.

A valid quantum operation in the middle of the product can break this, as a worked example showed. Some permutations are also costly to build. But for permutations that only flip and swap qubits, Hogancamp showed that the key part of the encoding needs just one gate with many controls.

Their firm claim is that every such factor can be completed. The one-gate cost holds only for the flip-and-swap class, and a boundary fix from a common way of discretising equations can still be completed, though it may raise that cost.

Search beyond plain Grover

Grover’s search is the yardstick for any quantum search. Three talks tried to beat it or bend it to new tasks, and each priced the result in depth, qubits or queries.

A faster quantum walk loses to Grover until n reaches 2 to the 13

Simone Perriello, a postdoc at Politecnico di Milano and a co-founder of Promethence, presented work with Alessandro Barenghi and Gerardo Pelosi. A Johnson graph links every subset of k items from n to the subsets that differ by one swap. Walks on it underlie search methods for problems such as subset sum. The team gave two circuits for one step of the walk, and the low-depth one cut its depth to the square of log n, which Perriello called exponentially better than earlier work.

The catch came in the count. Both designs were simulated, and full searches with a toy oracle found the marked item with a chance above 0.87 every time. Yet plain Grover diffusion stayed cheaper in T-depth until n reached about 2 to the 13. At 2 to the 5 the walk cost six times as much. On syndrome decoding, a problem tied to post-quantum cryptography, the gain vanished altogether, because there the oracle takes up most of the cost of each step.

Shrinking the register after each Grover call

Zefan Du presented a paper with Zihao Jiang, Shaolun Ruan, Juntao Chen, Yong Wang, Long Cheng, Rajkumar Buyya and Ying Mao. A Grover circuit stays full width for every call. RESAQuS shrinks. It drops the unlikely strings after each call, rebuilds a compact index and runs the next circuit on fewer qubits, and Du’s cost adds up the width of each circuit across all calls.

A 16-qubit search shrank through 13, 10 and 7 qubits for a total cost of 46, against 832 for plain Grover search and 72 for an earlier method, IQuCS. Du reported the highest fidelity of the three on an IBM machine and on emulators. Questioners asked whether one Grover step plus a classical index as large as the original search really earns the saving. Du offered no proof.

A Grover step for walking downhill on a mesh

Daniel Sierra-Sosa of the Catholic University of America presented a paper by Alejandro Giraldo Quintero, Sierra-Sosa and Adel Elmaghraby. The task is to walk downhill. At each point of a grid in n dimensions there are 3 to the n minus 1 neighbours, 8 in two dimensions and 26 in three, and the team’s oracle uses a subtractor to flag one that sits lower. A Grover-style search for the lowest then cuts the checks from M to about the square root of M.

Sierra-Sosa stressed that the count leaves out loading data, preparing states, the precision of the sums and readout. Ideal simulations passed every test. Noise models of IBM’s Fez and Torino smeared the output, and a few checks ran on ibm_marrakesh and ibm_fez with error reduction. Asked whether real problems lack enough structure for Grover to help, Sierra-Sosa said the team has no use case yet.

Signal processing and phase estimation

Two Wednesday talks dealt with routines that read out or reshape a hidden quantity. One of them ran on hardware.

Quantum signal processing runs on ions and a photonic chip

Yuan Liu of North Carolina State University showed quantum signal processing running on two kinds of hardware. The method mixes a fixed signal step with turns that can be tuned, so that a circuit of depth d applies a polynomial of degree d to a value hidden inside the step. The idea is old. Liu traced it to the pulse tricks of nuclear magnetic resonance, and said simulation, search and factoring can all be written this way.

With Norbert Linke’s group at the University of Maryland, the team moved states between qubits and one mode of motion of a five-ion chain. The measured states matched simulation. A second test used a photonic chip at room temperature to make step, ReLU and SELU functions with errors around one in a thousand. Lost photons, the main error, are flagged when they happen and can be filtered out.

Phase estimation still finds the energy under heavy Trotter error

Elijah Pelofske of Los Alamos National Laboratory presented work with Stephan Eidenbenz. Phase estimation reads an energy out of a system as a binary phase, using a register of phase qubits that sets the precision. Each extra qubit doubles the time it controls. So a fixed budget of small time steps, called Trotter steps, gets worse for the higher bits, and the error from cutting time into steps grows with it.

The team simulated full gate-level circuits for a three-qubit Heisenberg spin glass in Qiskit, with about 10 to the 5 shots per setting. Even with quite high Trotter error, sampling still converged to the ideal rate, though some estimates fell below the true energy. With heavy error at 10 phase qubits, first- and second-order steps behaved erratically. Fourth order converged. Pelofske agreed that with a starting overlap as large as 0.4, perhaps 10 shots would do.

What it means for algorithm designers

Anyone estimating what a quantum algorithm will cost should keep two ledgers. The first is the gate count, which these talks drove down by real margins, from half the Toffolis in a lookup table to a thousandfold fewer CNOTs for sparse quantum state preparation. The second holds the classical work done before the circuit runs and the classical rival running beside it. On that second ledger most papers did the work without pricing it, and none set a quantum clock beside a classical one.

Goldsmith’s three-way count, run through PsiQuantum’s Workbench tool, shows how far careful accounting can go, and Shukla’s rule of thumb shows the point where a stopwatch has to take over from the ledger. For the wider picture of what these parts build, see our guide to quantum algorithms. Yuan Liu’s runs on ions and a photonic chip show one part working on hardware, though they did not race a classical rival. Fujitsu’s shuffled table shows what a classical pass can save. Nobody has yet timed the search it serves.