wzeng

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.

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.

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

There’s more citations to gate fidelity progress here: https://metriq.info/Task/38

You can track resource estimates for different problems against QC performance here: https://metriq.info/progress

It crowdsources new submissions to the chart if there are ones you see missing (just open a PR)

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.

Another open source Python framework is Forest from Rigetti Computing. https://www.rigetti.com/products

A simple getting started post on a similar topic is here: https://medium.com/rigetti/how-to-write-a-quantum-program-in... which might be useful for comparison.

There is a Bay Area Quantum Computing meetup (I'm one of the organizers!)

https://www.meetup.com/Bay-Area-Quantum-Computing-Meetup/

Next one will likely be at the end of July. Hope to see you there!

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 support@rigetti.com

The access to quantum hardware is limited at this point, but we'll be adding new features over the coming months.

[0] http://www.rigetti.com/papers/Demonstration_of_Universal_Par... [1] http://pyquil.readthedocs.io/en/latest/qpu.html

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):

http://pyquil.readthedocs.io/en/latest/intro_to_qc.html

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.

[0] https://www.nersc.gov/news-publications/nersc-news/science-n... [1] https://arxiv.org/abs/1704.01127

There are libraries todat that let you do quantum programming! A simple Python library to get started with quantum programming is https://pyquil.readthedocs.io/en/latest/overview.html

The Python library allows you to construct quantum programs and output in a quantum/classical shared memory instruction set called Quil.

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:

IBM's API: https://github.com/IBM/qiskit-sdk-py

Rigetti Computing's Forest: http://forest.rigetti.com/ https://github.com/rigetticomputing/pyquil

ProjectQ: http://projectq.ch/

We added a really basic introduction to quantum programming into Forest that you might enjoy: http://pyquil.readthedocs.io/en/latest/intro_to_qc.html

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:

http://pyquil.readthedocs.io/en/latest/intro_to_qc.html

It goes through the basics of quantum computing using the Forest toolkit.

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:

https://www.youtube.com/watch?v=IpoASc18P5Q&feature=youtu.be

ProjectQ is another open source Python project out of ETH, and LIQUi|> is an F# simulator from Microsoft's quantum research group.

These would be the best place to start to see the cutting edge of developments in quantum programming.

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 will@rigetti.com

Yep it's coming, and that's right where you'll find it -[I'm one of the authors].

Really great to see people interested. Happy to answer questions in the meantime.