MIT Paper Shows Quantum Computers May Not Need to Get More Expensive as They Grow

Every quantum computer has to start somewhere. It has to prepare a clean starting state before it can run any algorithm. That step — quantum state initialization — has been assumed to get harder the bigger your machine is. MIT researchers say that assumption might be wrong.

In a preprint posted to arXiv on May 20, 2026, Aram Harrow and Isaac Chuang prove that quantum state initialization — the process of pulling a quantum system into a desired configuration — can achieve constant error scaling regardless of the system's local dimension. In other words: the resource cost does not grow as the quantum computer gets larger. It has been assumed to grow. The new result says it does not have to.

The MIT team solved the problem using generalized Young diagrams, a mathematical object from the nineteenth century that ended up precisely describing the structure of quantum state mixtures. By analyzing how these diagrams behave across copies of an input state, they derived the first dimension-uniform guarantee for optimal quantum purity amplification — the technical term for turning a noisy, mixed state into a high-fidelity copy of a target quantum state. "Achieving all-site error epsilon requires a number of input copies independent of d," the authors write, "scaling as O(m/(epsilon D_{k,min}^2))."

A companion preprint (arXiv:2605.21457) establishes what the result means in practice: coherent processing — operations that preserve quantum coherence across multiple copies of the input state — achieves error epsilon using O(1/epsilon) copies. Any incoherent protocol, meaning any approach that processes copies separately without maintaining coherence between them, requires Omega(d/epsilon) copies, where d is the local dimension. The separation is exponential in d. That is the kind of result the field notices.

The quantum state initialization problem is foundational. Every quantum algorithm begins by placing qubits into a known configuration. In real hardware, qubits are fragile — they decohere quickly, meaning they leak their quantum state into the environment and settle into thermal equilibrium. That equilibrium is a mixed state, colloquially noisy. Getting the system back into a target configuration — ideally, a pure eigenstate of some Hamiltonian — is the initialization step. In theory, doing this perfectly requires infinite resources. In practice, approximate initialization is what's needed. The question has always been how the cost of approximate initialization scales with system size.

The standard approach — the incoherent one — requires repeatedly copying the input state, measuring each copy, and post-selecting on outcomes that indicate proximity to the target state. Each measurement destroys the copy. You need many copies, and the number grows with the dimension of the system you're trying to initialize. That scaling has been a working assumption baked into hardware roadmaps: larger quantum computers face proportionally larger initialization costs. If those costs don't actually grow with dimension — or if they grow more slowly than assumed — the resource calculus for building fault-tolerant quantum machines changes.

The paper's own authors note what they have not yet characterized. They do not give gate counts, circuit depth, or qubit overhead for a physical implementation. These are the numbers practitioners need to assess whether the theoretical advantage translates to real hardware. An exponential separation in sample complexity is significant; whether it survives contact with a real quantum computer's error rates and connectivity constraints is a separate question that this paper does not answer.

This is a preprint. Both papers — the main result and the companion establishing the exponential separation — are posted simultaneously, which means neither has been peer-reviewed. The authors are MIT researchers with strong track records in quantum information theory, which is context that matters without being a substitute for review. The simultaneous posting of two connected preprints is unusual; it reads as an attempt to establish priority on a significant result before external validation, which is how the field works but which readers should be aware of.

The factual claim that matters most is dimensional uniformity: that initialization cost does not scale with local dimension under the coherent protocol. If that claim holds under scrutiny — if other researchers can verify it and find no hidden assumptions — it changes the picture for quantum hardware engineering. Initialization has been treated as a scaling bottleneck. If it is not one, every resource estimation that assumed it was carries headroom that may not be necessary.

The real test will be replication. Independent groups working through the math will determine whether the dimensional uniformity claim holds, whether the O(1/epsilon) scaling is achievable in practice, and whether the gate and qubit costs of the coherent protocol negate the theoretical advantage. That process takes time. The authors have posted early; the field will take the rest.

The quantum computing community has treated the initialization problem as a fact of life for two decades. It might have been a fact of life because it was assumed to be one. That distinction is worth watching — not because the MIT result is settled science, but because the question it raises is the right one: are we optimizing for bottlenecks that don't have to be there?