Quantum Computing: what are the biggest unsolved problems?

What is the biggest unsolved problem in quantum computing?

The biggest unsolved problem in quantum computing today is turning fragile physical qubits into enough reliable logical computation to solve something genuinely useful.

The physics is no longer the main source of doubt. We can make high-quality qubits, entangle them, manipulate them, encode them into logical qubits and correct some errors while a computation is running. Several pieces that once existed mostly on paper have now been demonstrated experimentally.

Google’s Willow processor gave one of the clearest demonstrations. Its distance-7 surface-code memory used 101 physical qubits and reached a logical error rate of about 0.143% per error-correction cycle. More importantly, increasing the code distance reduced the logical error rate rather than making the system worse. That is the behavior a fault-tolerant computer needs.

But 0.143% is still roughly one logical error every 700 cycles. Large algorithms may need millions, billions or even more reliable operations.

IBM’s roadmap makes the scale of the jump unusually clear. Its planned Starling system is designed around 200 logical qubits and 100 million gates. Getting there requires processors, quantum memory, decoding, modular connections and universal fault-tolerant gates to work together.

These days, the hardest question is how much machine we need to buy each reliable logical operation.

Layer	What already works	What remains difficult
Physical qubits	High-quality devices exist on several platforms	Scaling them without degrading quality
Logical memory	Errors can fall as codes grow	Reaching dramatically lower error rates
Logical computation	Key logical operations have been demonstrated	Running very long universal circuits
Full machine	Most ingredients exist separately	Making them work together at useful scale

Why does quantum error correction still need so many qubits?

Quantum error correction currently needs far too much hardware, and cutting that overhead could change the economics of quantum computing more than simply adding more physical qubits.

A physical qubit is fragile. A logical qubit spreads information across many physical qubits so that errors can be detected and corrected without directly measuring the quantum information we want to preserve.

The surface code became one of the leading approaches because it has relatively forgiving error thresholds and works with mostly local interactions. Its weakness is density. Depending on physical error rates and the reliability required, one useful logical qubit can consume hundreds or potentially thousands of physical qubits.

A computer requiring 1,000 logical qubits could therefore end up needing hundreds of thousands or millions of physical devices before we include extra resources for logical gates and state preparation.

This is why researchers are pushing quantum LDPC codes so aggressively. IBM’s bivariate bicycle codes, for example, are designed to encode substantially more logical information with fewer physical qubits. IBM’s own architectural estimates suggest that sufficiently large circuits could require around an order of magnitude fewer physical qubits than comparable surface-code implementations.

Higher-rate codes often require connections between qubits that are physically far apart. Surface codes waste more qubits but fit naturally onto simple two-dimensional grids; LDPC codes save qubits while making the hardware underneath them harder to build.

The race is increasingly about how cheaply a platform can manufacture one extremely reliable logical qubit.

Can logical qubits become reliable enough for huge quantum algorithms?

Logical qubits are getting better, but current quantum computers are still many orders of magnitude away from the reliability required by the longest useful algorithms.

Imagine a calculation requiring 100 million important logical operations. An error rate of one failure per million operations sounds excellent, yet we would still expect roughly 100 failures across the run.

Google showed that increasing its surface-code distance from five to seven reduced logical errors by roughly a factor of two.

As seen above, though, the absolute error rate was still around 0.143% per error-correction cycle. Moving from “errors get better as the code grows” to “errors are rare enough for 100 million useful gates” is a huge engineering climb.

Rare failures make the problem nastier. In extended experiments, Google observed unusual correlated events on timescales of roughly once per hour. Events that look negligible in short laboratory runs can eventually dominate a computer that operates continuously across enormous numbers of qubits.

Current quantum error correction has passed an important scientific test without yet reaching the reliability required by the biggest algorithms.

How hard is it to perform useful gates on error-corrected qubits?

Performing universal fault-tolerant gates is still one of quantum computing’s biggest bottlenecks because protecting a logical qubit is easier than doing arbitrary computation with it.

Some operations fit naturally inside common quantum error-correcting codes. Others require extra resources.

The best-known example involves non-Clifford operations such as the T gate. Many fault-tolerant architectures implement them using specially prepared “magic states.” Those states have to be exceptionally clean, so imperfect versions are combined through a process called magic-state distillation.

A major recent step came from QuEra, Harvard and MIT, which demonstrated magic-state distillation entirely with logical qubits on a neutral-atom processor.

Magic states are still expensive. Large algorithms could need enormous numbers of them, forcing future systems to dedicate substantial hardware just to producing a steady stream of these resources.

Finding cheaper universal logical gates could remove one of the largest hidden taxes in fault-tolerant quantum computing.

Which quantum hardware is actually winning right now, and does qubit count tell us anything useful?

The quantum hardware race is still wide open today, and raw qubit count is increasingly a poor way to judge it.

Superconducting qubits remain among the strongest candidates because gates are fast, fabrication is relatively mature and companies such as Google and IBM have already used them for important error-correction experiments. Their pain points are wiring, cooling, device variation and scaling large connected processors.

Trapped ions offer exceptional fidelities and naturally identical qubits. They can also connect distant qubits more flexibly than most solid-state systems. The trade-off is much slower gate operation and increasingly complicated optical control as systems grow.

Neutral atoms have gained ground quickly. Large numbers of identical atoms can be assembled into reconfigurable arrays, moved during computation and arranged in geometries that suit different error-correcting codes.

Photonics makes another bet: build quantum computing around photons, optical networks and semiconductor manufacturing. Its networking advantages are attractive, but photon loss and the amount of hardware required for fault tolerance remain difficult.

Silicon spin qubits could reach exceptional density and potentially use technologies inherited from the semiconductor industry. Researchers have already shown promising wafer-scale fabrication and cryogenic control, although operating huge numbers of nearly identical high-fidelity devices remains unresolved.

Topological quantum computing carries the biggest potential shortcut and the biggest scientific uncertainty. Microsoft released Majorana 2 after its controversial Majorana 1 announcement, yet outside researchers still dispute whether the experiments prove the topological behavior required for the claimed architecture.

These platforms make headline qubit numbers misleading. Ion-trap machines may have fewer qubits but unusually strong connectivity. Superconducting systems run much faster but generally use local connections. Neutral atoms can rearrange qubits during computation, while photonic architectures do not map neatly onto a fixed grid at all.

IBM increasingly describes future machines using executable gate counts alongside logical qubits. Starling’s target of 200 logical qubits and 100 million gates says far more about the intended machine than “200 qubits” alone.

Platform	What looks strongest	What could still stop it
Superconducting	Fast gates and mature control	Cooling, wiring and scaling
Trapped ions	Very high fidelity	Speed and optical complexity
Neutral atoms	Large flexible arrays	Full fault-tolerant system performance
Photonics	Networking and manufacturing potential	Loss and resource overhead
Silicon spins	Density and CMOS compatibility	Uniform large-scale control
Topological	Potentially much lower error overhead	The core physics is still disputed

If you want more recent data on this point, please see our latest quantum computing market report.

Can we actually manufacture and control millions of quantum qubits?

We do not yet know how to manufacture and control millions of quantum qubits as one reliable computer, although this problem has started to look more like hard engineering than science fiction.

Imec researchers demonstrated superconducting transmon qubits fabricated with industrial processes on 300-millimetre wafers. They characterized 400 qubits and 12,840 Josephson-junction test structures, while coherence times exceeded 100 microseconds.

That is a meaningful move toward statistical manufacturing. Semiconductor factories work because engineers understand yields, variation and defects across entire wafers; large quantum processors will need the same discipline.

Control is just as difficult. Many current solid-state machines connect cold qubits to racks of room-temperature electronics through large numbers of cables. Extending one control path per qubit toward millions of qubits quickly becomes physically ridiculous.

One recent Nature experiment controlled silicon spin qubits using cryogenic CMOS containing roughly 100,000 transistors. The integrated electronics could perform universal control without a measurable loss of qubit coherence in the tested device.

IBM has lately pushed the problem from chips toward complete infrastructure. It connected and cooled two modular cryogenic systems in a shared environment designed to evolve toward hundreds of linked quantum chips.

Million-qubit control remains unsolved, but the engineering path is becoming much more concrete.

Can separate quantum chips work together while classical computers keep up with the errors?

Quantum processors can now compute across separate modules, but scaling that architecture also means building a classical control system fast enough to keep every module corrected in real time.

Modularity is attractive because manufacturing one gigantic perfect chip becomes harder as processors grow. Quantum information makes the connection difficult because an unknown quantum state cannot simply be copied and sent down a wire.

Researchers instead distribute entanglement between modules and use it to perform operations such as quantum gate teleportation.

Oxford researchers demonstrated distributed quantum computing across two photonically linked trapped-ion processors and performed a quantum algorithm using gates executed between the modules. The remote gate was deterministic and repeatable enough to act as part of a computation.

IBM is pursuing modularity at several levels as well. Its roadmap moves from individual modules toward entangled fault-tolerant modules before the planned Starling architecture.

But every additional module also feeds more error information into the classical side of the machine.

Quantum error correction continuously produces syndrome measurements. A classical decoder has to infer what probably went wrong before too many new errors accumulate.

Google has demonstrated real-time decoding alongside a distance-5 surface code, while IBM treats real-time decoding as a separate milestone in its fault-tolerant roadmap.

At large scale, thousands or millions of physical qubits could generate huge syndrome streams across many connected modules simultaneously. The links need to stay fast and reliable while the decoders remain accurate enough and quick enough to keep the computation alive.

We know both pieces can work at small scale. Their combined scaling is still unproven.

Where could quantum computing deliver its first useful advantage, and why are useful algorithms still so rare?

The first useful quantum advantage will probably come from a narrow scientific calculation because very few quantum algorithms still look compelling after we count their full real-world cost.

Quantum processors have already performed tasks that are extremely hard to reproduce through direct classical simulation. More recently, IBM and University of Chicago researchers reported encoded circuits involving 70 logical qubits whose output could be checked even though leading classical simulation approaches could not feasibly reproduce the computation.

That strengthens the case that quantum machines can enter computational territory beyond straightforward classical simulation.

The harder problem is finding a calculation somebody actually needs.

Shor’s algorithm remains the clearest theoretical example: factoring large integers changes fundamentally on a sufficiently large fault-tolerant machine. Grover’s algorithm also provides a general quadratic improvement for unstructured search.

Beyond those famous cases, many proposed speedups become less impressive once we include data loading, fault tolerance, deep circuits, auxiliary states and repeated measurements.

This is why researchers spend so much effort reducing resource requirements. In quantum chemistry, better Hamiltonian simulation, molecular representations and state-preparation techniques can cut gate counts by orders of magnitude. Turning a trillion-gate calculation into a ten-billion-gate one is effectively a 100-fold hardware improvement achieved through software.

The strongest commercial candidate still looks like a calculation inside chemistry, materials science or another quantum-physics workflow where classical simulation becomes brutally expensive.

Optimization remains plausible but much less settled, while machine learning has difficult input and deployment costs.

The field needs more algorithms where the advantage survives the entire calculation and still beats a highly optimized classical alternative.

If you want more recent data on this point, please see our latest quantum computing market report.

Can quantum computers really beat classical optimization?

Quantum computers still have no convincing general win over the best classical optimization methods on commercially meaningful problems.

Optimization attracts enormous attention because routing, scheduling, portfolios, logistics and industrial planning are economically valuable and often computationally difficult.

The leap from “hard classical problem” to “good quantum application” is where the case becomes weak.

A recent Nature Computational Science study found encouraging scaling behavior for enhanced quantum solvers on an NP-complete one-in-three satisfiability problem with numerical experiments reaching 70 variables. That is interesting evidence in a controlled setting, but it is far from a company rerouting thousands of delivery vehicles or optimizing a large factory.

Classical algorithms fight back quickly. Work published in Nature Communications showed that probabilistic classical computers can compete strongly on hard optimization benchmarks that had been used to explore quantum advantage.

A quantum method improves, researchers strengthen the classical baseline, and the gap often gets smaller.

Optimization remains promising but unproven until we see a repeatable wall-clock, cost or solution-quality win against a realistic classical solver.

Is quantum chemistry really the best use case?

Quantum chemistry is currently the strongest candidate for a major fault-tolerant quantum application. The decisive commercial win is still missing.

Molecules are quantum systems. Representing their electronic states becomes extremely expensive on classical computers as molecular complexity and required accuracy increase.

Algorithms such as quantum phase estimation could eventually calculate molecular energies with accuracy that becomes prohibitively expensive for exact classical methods. Potential targets include strongly correlated molecules, catalysts and materials where tiny energy differences change useful properties.

Quantum computers still have to beat the methods chemists actually use.

Density-functional theory, coupled-cluster techniques, Monte Carlo methods, tensor networks and increasingly powerful machine-learning potentials already solve a huge amount of useful chemistry.

The valuable quantum calculation therefore has to sit in a region where classical approximations break down, a fault-tolerant quantum computer can handle the problem, and the answer is worth enough money to justify expensive computing.

Chemistry has perhaps the strongest scientific case today. The commercial case still depends on finding specific calculations where those three conditions line up.

If you want more recent data on this point, please see our latest quantum computing market report.

Can quantum machine learning actually beat normal AI?

Quantum machine learning has not shown a broad practical advantage over classical AI, and conventional machine learning is improving much faster than quantum hardware can currently challenge it.

Most machine-learning data starts as ordinary classical information: images, numbers, transactions, medical records or text-derived features. A quantum algorithm may look extremely fast after the information has been encoded into a quantum state, but preparing that state can consume much of the theoretical advantage.

Output creates another cost. Quantum measurements reveal limited information at once, so algorithms may need repeated executions to estimate results accurately.

Deployment can also be awkward. A classical model can often be copied and run cheaply across GPUs, phones or servers. Some quantum models would need repeated access to scarce quantum hardware every time they make predictions.

Recent surveys covering more than a hundred quantum-machine-learning studies still highlight hardware noise, scalability and practical data handling as central barriers. The literature contains plenty of experiments and hybrid models, but little evidence that businesses should replace strong classical ML pipelines with quantum ones.

A more convincing first use may involve data that is quantum from the beginning, such as states generated inside a quantum experiment.

For ordinary enterprise AI, quantum machine learning remains much more speculative than the marketing around it suggests.

How can we trust a quantum answer that no classical computer can check?

Verifying quantum computers is becoming a serious problem because the most interesting calculations are precisely the ones we eventually cannot reproduce classically.

Small quantum circuits are straightforward to test. We simulate them on a classical machine and compare the output. That approach eventually collapses as quantum circuits become too large.

Researchers then need indirect ways of checking whether the result is trustworthy. They can test smaller versions, exploit mathematical properties of the circuit, compare against independently calculated quantities or design computations that contain their own verification structure.

The recent IBM–University of Chicago work pushes directly on this problem. Researchers ran encoded circuits across 70 logical qubits and designed the experiment so that the fidelity of the output could still be established without brute-force classical reproduction.

Application-level verification could become harder still. A physicist receiving an unexpected material property or molecular energy needs some reason to trust the answer before spending months and millions of dollars testing it experimentally.

Quantum computing will need reliable ways to cross-check answers without simply rerunning the entire calculation classically.

Will Microsoft’s topological qubits solve the scaling problem?

Microsoft’s topological approach could slash quantum error-correction overhead. The evidence is still too disputed to treat topological qubits as a solved shortcut.

The attraction is easy to understand. Conventional qubits are highly sensitive to local noise. A topological qubit is meant to store information in a more globally protected physical state, making certain local disturbances much less damaging.

If that works well, fault-tolerant quantum computers could require dramatically less active error correction.

Microsoft’s Majorana 1 announcement reignited interest in this path, and the company has since introduced Majorana 2 as the next step in the architecture.

Researchers have continued challenging whether Microsoft’s measurements establish the topological states needed for the proposed qubits. Nature reported that physicists remained skeptical even after the updated chip, with critics arguing that alternative explanations for the measurements had not been ruled out convincingly.

Other leading platforms already have well-established physical qubits and are fighting to scale them. Microsoft is still trying to prove that its unusual building block behaves as required while building an architecture around it.

The payoff would be enormous if the approach works. For now, it remains the field’s highest-upside shortcut rather than its safest route.

If you want more recent data on this point, please see our latest quantum computing market report.

Could rare errors ruin quantum computers even if average error rates look great?

Rare correlated errors could absolutely ruin large quantum computers because failures that seem negligible on a small chip become routine across billions of operations.

Error-correction performance is often summarized using average rates. Real devices can also experience leakage, radiation events, shared-control failures or other disturbances affecting several qubits together.

Quantum error-correcting codes usually cope best when errors are sufficiently independent. A correlated event can violate those assumptions.

Long-running error-correction experiments have already revealed this problem. Google observed rare correlated events roughly once per hour in one set of extended experiments, creating an error floor far below ordinary physical error rates but still potentially important for extremely long computations.

Scale that behavior to thousands of logical qubits running continuously and rare events become normal operational problems somewhere inside the machine.

Future systems will have to survive those outliers, not merely report impressive average fidelity.

Can quantum computing ever become cheap enough to matter commercially?

Quantum computing can become commercially useful while remaining extremely expensive, but the value of its calculations eventually has to exceed the full cost of producing them.

We currently know very little about the eventual cost of a fault-tolerant quantum operation.

A superconducting system needs dilution refrigerators, microwave equipment, control electronics and substantial classical computing. Trapped-ion machines require lasers, optics and ultra-high vacuum. Photonic systems trade some of those problems for photon generation, switching and detection. Error correction adds more hardware on every platform.

An expensive machine can still be a good business. The first useful quantum computers could resemble early supercomputers: scarce systems used for problems whose answers are valuable enough to justify extraordinary infrastructure.

Economics become tougher when the quantum system competes with a classical approximation that already produces a good-enough answer cheaply.

IBM’s current roadmap pairs quantum processors with HPC, modular cryogenic systems and workflow software rather than treating quantum computers as standalone replacements for classical data centers.

The key number will eventually be the cost of a reliable logical computation compared with the value and classical cost of the same result.

Does quantum computing still pose a real threat to encryption?

Quantum computing still poses a serious long-term threat to RSA and elliptic-curve cryptography, even though today’s quantum computers are nowhere near running the required attack at useful scale.

Shor’s algorithm is not speculative. A sufficiently large fault-tolerant quantum computer would fundamentally change the difficulty of factoring integers and solving the discrete-logarithm problems underlying widely used public-key cryptography.

Breaking large cryptographic keys would require far more reliable logical computation than current systems provide.

Governments are nevertheless migrating now because replacing cryptography across banks, governments, browsers, devices and industrial systems can take years.

NIST has already finalized ML-KEM for key establishment and ML-DSA and SLH-DSA for digital signatures. Its guidance is explicit that organizations should begin the transition before a cryptographically relevant quantum computer exists.

Attackers can also steal encrypted information today and store it. If the information still matters years later, a future quantum computer could decrypt what was collected earlier.

Post-quantum cryptography itself continues to be stress-tested. One additional candidate, HAWK, was recently withdrawn from NIST’s process after researchers found a vulnerability with help from an AI system. NIST stressed that the issue does not affect its already finalized standards.

Question	Where we are now
Can quantum computers break RSA today?	No
Would a large fault-tolerant machine threaten RSA?	Yes
Does that machine exist?	No
Are replacement standards available?	Yes
Is migration already justified?	Yes

If you want more recent data on this point, please see our latest quantum computing market report.

What would finally prove that quantum computing works?

Quantum computing will have truly arrived when a quantum machine repeatedly solves an important problem better than the strongest realistic classical alternative.

The problem should have value before anyone mentions quantum computing. Its result should be trustworthy, and the comparison should use optimized classical methods rather than deliberately weak baselines.

Cost also has to enter the comparison. A five-minute quantum calculation is not automatically superior to a ten-hour classical one if the quantum machine costs vastly more to operate. Conversely, a very expensive quantum machine can still win if the classical calculation would otherwise require months, impossible amounts of memory or an approximation that misses the relevant physics.

Current demonstrations are getting closer to pieces of that test. We have quantum computations that push beyond feasible direct classical simulation, improving logical error correction, logical magic-state distillation, modular quantum computation and encoded-circuit experiments that combine classical difficulty with stronger verification.

As pointed out above, those ingredients still have not converged on the result that would settle the argument: an independently reproducible, economically meaningful application where the quantum route wins end to end.

Chemistry or materials science currently looks like the best place to expect that moment. It could initially be one narrow subroutine inside a much larger classical workflow.

So what are the biggest unsolved problems in quantum computing?

The biggest unsolved problems in quantum computing now all converge on the same question: can we produce enough cheap, reliable logical operations to make an important algorithm worth running?

Error correction has made real progress. Logical qubits can beat their underlying physical components under the right conditions. Universal fault-tolerant ingredients such as magic-state distillation have entered the laboratory. Modular quantum computation works at small scale. Industrial fabrication and cryogenic control are improving.

The remaining job is to make those advances work simultaneously.

Logical errors need to fall by many orders of magnitude for the longest algorithms. Error correction still consumes too much hardware. Universal logical gates carry large hidden overheads. Control and decoding have to scale alongside the quantum processor. Manufacturing must become repeatable enough for machines containing enormous numbers of components.

Algorithms then have to justify the machine.

Quantum chemistry has a credible path. Cryptography has a clear theoretical case but requires a much larger computer. Optimization and machine learning remain much less proven despite years of attention.

We increasingly know what a fault-tolerant quantum computer needs to look like. We still do not know whether engineers can make it efficient enough for its most valuable algorithms to beat classical computing in the real world.

Who is the author of this content?

NEW MARKET PITCH TEAM

We track new markets so founders and investors can move faster

We build living "market pitch" documents for emerging markets: AI, synthetic biology, new proteins, and more. Instead of outdated PDFs or hallucinated LLM answers, our clients get a clean, visual, always-updated view of what's really happening: key players, deals, regulations, and signals that matter. Learn more about us.