We don’t need exponentially more physical qubits because we have quantum error correction schemes that exponentially decrease the logical error rate with only a polynomial increase in the number of qubits. There are in fact many schemes for this (https://errorcorrectionzoo.org/) with the surface code mentioned in the blog being a leading approach.
There will be engineering challenges to scale up these implementations but in principal you shouldn’t need exponential resources (unless there is something wrong with quantum mechanics). This sort of error correction scaling does not exist, for example, for analog computing.
Several approaches are better than the break even point today, including the Google demonstration of error correction working to reduce logical errors: https://www.nature.com/articles/s41586-024-08449-y
The cQASM that you link to is one of the flavors of QASM. Another commonly used one is openqasm whose 2.0 and 3.0 specs are here: https://github.com/Qiskit/openqasm
Along with QIR like as is listed in the comment, these are two open assembly specs with collaborative governance. Another is Quil: https://github.com/quil-lang/quil
While quantum computing has a history of using circuit diagrams (which are still very useful) to represent programs. These languages have representations under the hood that look a lot more like assembly. For example: https://github.com/Qiskit/openqasm/blob/master/examples/adde...
If open source quantum computing is your thing then https://unitary.fund/ could use help supporting and mentoring projects. We're domain specific, but this might be a model others can follow.
This is a great question! I've worked a lot on this topic and its crucial to understanding how quantum computers will be used in the near term.
While I don't have an easy answer for the high level interface, the assembly level interface between quantum and classical computing is also important. If you're interested in that then you should check out this paper where we describe Quil, an instruction set architecture for hybrid quantum/classical computing based on shared memory: https://arxiv.org/abs/1608.03355
This instruction set is the basis for Rigetti Computing's Forest quantum programming environment: https://www.rigetti.com/forest
We haven't integrated arbitrary circuit execution features in yet, but when we do we'll make the transition as smooth as possible.
It's important to remember though that noise is a fact of life for this generation of small prototype quantum processors. You'll definitely see a difference between a perfect simulation and true hardware.
Signing up automatically gives you access to run on the simulator. For select users, we are providing some limited access to one of our prototype quantum processors. It's the one discussed in this paper [0]. This initial access doesn't allow a user to run full quantum programs like on the simulator, but but one can test out a few interesting experiments. You can read about what experiments are available here [1]. If you'd like to apply to run some experiments on our hardware then email us with some information about you and your interests at [email protected]
The access to quantum hardware is limited at this point, but we'll be adding new features over the coming months.
If you're looking for a short, and practical introduction using Python, then one is included as part of the documentation for pyQuil (part of the Forest toolkit):
The largest full quantum computer simulation done so far is 45-qubits which was performed on the Cori supercomputer [0][1]. The main limitation in these kinds of exact simulations is memory, and so simulating 50-qubits would require about a 1000x the memory of Cori, which is infeasible.
There are some other methods of approximate simulation, but that gives the cut off for full, exact simulation of a quantum computer.
Thinking about this demonstration as an experiment could be a little misleading. It's somewhere between an experiment and a benchmark. Nobody has any reason to expect new physics between 10 and 50 qubits, but actually building and controlling the system is complicated. Quantum computing is in an interesting place right now where engineering milestones and scientific milestones are happening together because the technology is so fundamental.
That doesn't happen that often and it's one of the most exciting things to be about being in the field. If that interest you, then you might want to come work at Rigetti Computing: "The Tiny Startup Racing Google to Build a Quantum Computing Chip" https://www.technologyreview.com/s/600711/the-tiny-startup-r... We're hiring.
The best book out there is still Quantum Computation and Quantum Information by Nielsen and Chuang. It isn't quite current, as it lacks both the advances in hardware (superconducting qubits) and algorithms (quantum/classical hybrids & the sampling benchmark that this article is talking about). It's still the best way to get started as it introduces everything from the linear algebra all the way up.
I work in quantum computing and it's the book I always recommend.
This is great! There's a really cool ecosystem of Python tools for quantum computers that's coming out. Check them out if you'd like to learn more about quantum programming:
The textbook by Nielsen and Chuang is great. If you're looking for an abridged interactive one then you might be interested in the one in the documentation for pyQuil:
This list is great, but appears to be a little out of date. A new crop of programming tools has recently emerged as the field grows from academia into industry efforts:
Forest http://forest.rigetti.com is an open source Python toolkit out of the startup Rigetti Computing (full disclosure I'm a co-founder of this project). Here's a link to a recent demo and tutorial:
Hi Xcelerate, Will Zeng from Rigetti Computing here. While you're right that it is a bit of a move, backgrounds in computational chemistry are very interesting to us as quantum simulation, especially electronic structure, is a big application area for near term QC.
If you or anyone else with similar background is looking to get into quantum computing, then send along your resume at [email protected]
Details for how this could work for factoring are here: https://arxiv.org/abs/1905.09749
There will be engineering challenges to scale up these implementations but in principal you shouldn’t need exponential resources (unless there is something wrong with quantum mechanics). This sort of error correction scaling does not exist, for example, for analog computing.