Hello (Many Quantum) World(s)

Historically, the first program you write for a new computer language is “Hello World,” or, if you are in Texas, “Howdy World.” But with quantum computing on the horizon, you need something better. Like “Hello Many Worlds.” [IonQ] proposes what that looks like and then writes it in seven different quantum languages in a post you should check out.

Here’s the description of the simple program:

The basic quantum program we’ll write is simple. It creates a fully-entangled state between two qubits, and then measures this state. This state is sometimes called a Bell State, or Bell Pair, after physicist John Stewart Bell.

The measurement results for this program should give us 0 for both qubits or 1 for both qubits, in equal amounts. When running these, we’ll be able to tell that we’re running on real hardware because that’s not always what we get! These errors are what currently limit quantum computers, but the first steps to overcome this with quantum error correction have already begun.

Continue reading “Hello (Many Quantum) World(s)”

IBM Eagle Has A Lot Of Qubits

How many qubits do you need in a quantum computer? Plenty, if you want to anything useful. However, today, we have to settle for a lot fewer than we would like. But IBM’s new Eagle has the most of its type of quantum computer: 127-qubits. Naturally, they plan to do even more work, and you can see a preview of “System Two” in the video below.

The 127 qubit number is both impressively large and depressingly small. Each qubit increases the amount of work a conventional computer has to do to simulate the machine by a factor of two. The hope is to one day produce quantum computers that would be impractical to simulate using conventional computers. That’s known as quantum supremacy and while several teams have claimed it, actually achieving it is a subject of debate.

Like any computer, more bits — or qubits — are better than fewer bits, generally speaking. However, it is especially important for modern quantum systems since most practical schemes require redundancy and error correction to be reliable in modern implementations of quantum computer hardware. What’s in the future? IBM claims they will build the Condor processor with over 1,000 qubits using the same 3D packaging technology seen in Eagle. Condor is slated for 2023 and there will be an intermediate chip due in 2022 with 433 qubits.

Scaling anything to a large number usually requires more than just duplicating smaller things. In the case of Eagle and at least one of its predecessors, part of the scaling was to use readout units that can read different qubits. Older processors with just a few qubits would have dedicated readout hardware for each qubit, but that’s untenable once you get hundreds or thousands of qubits.

Qubits aren’t the only measure of a computer’s power, just like a conventional computer with more bits might be less capable than one with fewer bits. You also have to consider the quality of the qubits and how they are connected.

Who’s going to win the race to quantum supremacy? Or has it already been won? We have a feeling if it hasn’t already been done, it won’t be very far in the future. If you think about the state of computers in, say, 1960 and compare it to today, about 60 years later, you have to wonder if that amount of progress will occur in this area, too.

Most of the announcements you hear about quantum computing come from Google, IBM, or Microsoft. But there’s also Honeywell and a few other players. If you want to get ready for the quantum onslaught, maybe start with this tutorial that will run on a simulator, mostly.

Continue reading “IBM Eagle Has A Lot Of Qubits”

Twist Promises Easier Quantum Programming

We keep trying to learn more about quantum computers. But the truth is, the way we program quantum computers — or their simulators — today will probably not have much in common with how we program them in the future. Think about it. Programming your PC is nothing like programming the ENIAC. So we expect we’ll see more and more abstractions over the “bare metal” quantum computer. The latest of these is Twist, from MIT.

According to the paper (and the video, below), Twist expresses entangled data and processes in a way that traditional programmers can understand. The key concept is known as “purity” of expressions which helps the compiler determine if data is actually entangled with another piece of data or if any potential entanglement is extraneous. A pure expression only depends on qubits it owns, while a mixed expression may use qubits owned by other expressions.

Continue reading “Twist Promises Easier Quantum Programming”

Arduino Meets Quantum Computer

Quantum computers aren’t quite ready for the home lab, but since there are ways to connect to some over the Internet, you can experiment with them more easily than you might think. [Norbert] decided to interface a giant quantum computer to an ordinary Arduino. Why? Well, that isn’t necessarily clear, but then again, why not? He explains basic quantum computing and shows his setup in the video below.

Using the IBM quantum computer and the open source Qiskit makes it relatively easy, with the Python code he’s using on the PC acting as a link between the Arduino and the IBM computer. Of course, you can also use simulation instead of using the real hardware, and for such a simple project it probably doesn’t matter.

Granted, the demo is pretty trivial, lighting an LED with the state of qubit. But the technique might be useful if you wanted to, say, gather information from the real world into a quantum computer. You have to start somewhere.

We’ve looked at quantum computers before. They tell us it is the next big thing, so we want to be prepared. Qiskit is one of several options available today to make it easier.

Continue reading “Arduino Meets Quantum Computer”

Quantum computer

Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle

Quantum computers are really in their infancy. If you created a few logic gates with tubes back in the 1930s, it would be difficult to predict all the ways we would use computers today. However, you could probably guess where at least some of the problems would lie in the future. One of the things we are pretty sure will limit quantum computer development is error correction.

As far as we know, every quantum qubit we’ve come up with so far is very fragile and prone to random errors. That’s why every practical design today incorporates some sort of QEC — quantum error correction. Of course, error correction isn’t news. We use it all the time on unreliable storage media or communication channels and high-reliability memory. The problem is, you can’t directly clone a qubit (a quantum bit), so it is hard to use traditional error correction techniques with qubits.

After all, the whole point to a qubit is we don’t measure it until the end of the computation which, like Schrödinger’s cat, seals its fate. So if you were to “read” a bunch of qubits to form a checksum or a CRC, you’d destroy their quantum nature in the process making your computer not very useful. You can’t even copy a bit to use something like triple redundancy, either. There seems to be no way to practically duplicate a qubit.

Continue reading “Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle”

New Silq Programming Language Aims To Make Quantum Programming Easier

Fresh from ETH Zurich comes the new Silq programming language. They also have submitted a paper to the PLDI 2020 conference on why they feel that it is the best quantum programming language so far. Although it may be not common knowledge, the lack of usable general purpose quantum computers has not kept multiple teams from developing programming languages for such computer systems.

Microsoft’s Q# is a strong contender in this space, along with the older QCL language. The claims by the Silq team on exactly why their language is better appear to come down to it being ‘more high level’, and by supporting automatic (and safe) uncomputation. While the ‘high level’ aspect is suspect since Q# is most decidedly a high-level programming language, their uncomputation claim does at least have some merit.

Quantum algorithm with uncompute step.

Uncomputation is a concept in quantum programming, where one occasionally has to remove a few intermediate objects from the current state because they may cause quantum interference that would affect the resulting output. Normally, one would save the intermediate result to a register for this, then reset the state and continue. Which parts of the state to keep and what to uncompute is however not easily determined, as a quick glance at related answers over at the Quantum Computing StackExchange and Theoretical Computer Science might reveal.

The main question thus appears the validity of this claim about Silq being able to automatically determine what ‘garbage’ can be safely uncomputed, and what should be part of the quantum interference. We have all seen with languages like Java and C# how even with traditional computing something as simple as garbage collecting can go horribly wrong. Maybe we shouldn’t count our quantum chickens yet until this particular waveform has fully collapsed.

(Thanks to Qes)

Learn Quantum Computing With Spaced Repetition

Everyone learns differently, but cognitive research shows that you tend to remember things better if you use spaced repetition. That is, you learn something, then after a period, you are tested. If you still remember, you get tested again later with a longer interval between tests. If you get it wrong, you get tested earlier. That’s the idea behind [Andy Matuschak ‘s]and [Michael Nielsen’s] quantum computing tutorial. You answer questions embedded in the text. You answer to yourself, so there’s no scoring. However, once you click to reveal the answer, you report if you got the answer correct or not, and the system schedules you for retest based on your report.

Does it work? We don’t know, but we have heard that spaced repetition is good for learning languages, among other things. We suspect that like most learning methods, it works better for some people than others.

Continue reading “Learn Quantum Computing With Spaced Repetition”