Seeing Quantum Simulators

From PhysicsWorld.com: Quantum simulators revealed in fresh detail. What I found the most interesting in the article:

"A Mott insulator with exactly one atom per lattice site represents a very promising candidate for a quantum register of up to a few hundred atomic quantum bits," adds Kuhr. "However, we needed to show that we really are able to manipulate each individual atom in the structure. This is crucial for encoding and reading out qubits and we are now at the beginning of setting up the first experiments of this kind."

There is also an article in Nature here.

arXiv: Simulating Chemistry with Quantum Computers

I came across this in today's arXiv listing: Simulating Chemistry with Quantum Computers. Here's the abstract:

The difficulty of simulating quantum systems, well-known to quantum chemists, prompted the idea of quantum computation. One can avoid the steep scaling associated with the exact simulation of increasingly large quantum systems on conventional computers, by mapping the quantum system to another, more controllable one. In this review, we discuss to what extent the ideas in quantum computation, now a well-established field, have been applied to chemical problems. We describe algorithms that achieve significant advantages for the electronic-structure problem, the simulation of chemical dynamics, protein folding, and other tasks. Although theory is still ahead of experiment, we outline recent advances that have led to the first chemical calculations on small quantum information processors.

It is well known that a simulation of a general quantum system on a classical computer experiences an exponential slow down. As the title states, this paper describes how a quantum computer can be used to avoid this problem in Chemistry.

Simulating Quantum Computers

Here's a good blog post by Tucci: Best Heavy Duty Quantum Computer Simulators. He basically breaks them down into two categories: super computers and distributed grids (like BOINC). For anything heavy duty that is a simulation on a classical computer, those types of approaches are the only real solutions.

There are some approaches to help on a modern PC, although your still much more limited than the above. A quantum register is represented by 2^n complex numbers, where an operation on that register is a 2^n x 2^n matrix of complex numbers. The simple approach is just that, but as you can see, the memory requirements are large: you'll need 2^n complex numbers for the initial state of the register, the 2^n x 2^n complex matrix for the operation, and 2^n complex numbers for the output. One way to cut down the memory needed is to only do the matrix multiplication one row at a time. Doing so you need only 2^n complex numbers for the matrix instead of the entire thing. This is how the current implementation of Cove, my framework for programming quantum computers, currently works. Of course, there are much more elaborate tricks out there for improving the efficiency of quantum computers.

Another area I've been toying with for some time is to utilize more than one core on a system. The easiest approach with the current implementation of Cove would be just to spawn extra threads to do the matrix multiplication pieces. This would come at the cost of the extra 2^n complex numbers for each thread running. So there is a trade off between memory use and faster execution of the simulation. The execution time has been the bottle neck for a lot of the sets of a few handfuls of qubits I've been playing with, so this is something I'll probably get to eventually.

The previous paragraph being said, my goal has always been the creation of a usable framework for quantum computer programming. The simulation has always been something that will allow me to play with existing code, so my focus has never been on making it incredibly efficient.

Cove is setup where a user writes their code against a set of interfaces. With the current incarnation of Cove, the implementation is this simulation I've been talking about. The idea is however, that the simulation implementation could eventually be swapped out with one that runs on an actual quantum computer. In doing so a users code could switch between various implementations (actual quantum computer, my simulation, super computer, grid, etc) with only switching a reference and using statement.

Supercomputer simulates QC with 42 qubits

JUGENE simulates a quantum computer with 42 qubits. That may not sound impressive to those not familiar with simulating quantum computers, but it is pretty remarkable they could do that many qubits. To simulate an arbitrary quantum state requires a matrix of 2^n complex numbers to simulate n qubits. For 42 qubits that is 4,398,046,511,104 complex numbers.

Given this exponential growth, it wasn't too surprising that I ran into size constraints quickly when working on Cove. For the following example I did a simple case of putting the entire register in superposition, then measuring it. This was done on an Intel Core Duo T2300 with 1 GB of RAM maybe a year and a half ago. The jump between 9 and 10 qubits really illistrates how the exponential slow down happens in a simulation of an arbitrary quantum system.

Structured Design Process and Drug Development

Alexander Christakis writes a lot about using the structured design process (SDP) in his book "How People Harness their Collective Wison and Power to Construct the Future in Co-Laboratories of Democracy" [1]. (You can get it here on Amazon in hardcover.) In particular in chapter 14 he writes about how using SDP can short end the front end work necessary for drug development. As an example he suggests workshops that can cut time for some processes down from weeks or months to just a few days. I think the key point is really that we can dramatically decrease the time our processes take just by changing the process itself.

Drug development is one area I think quantum computing holds the potential to really make an impact in. Often when one hears about quantum computing Shor's algorithm (factoring) and Grover's algorithm (unsorted search) are the two examples that are frequently cited. Simulating quantum systems is often missing from this list. Just think of what all we'd be able to do if we could efficiently simulate a quantum system (via a quantum computer)... I think this extends beyond drugs into physics and probably a bunch of other areas we cannot even think of at this point.

References
[1] A. N. Christakis and K. C. Bausch, How People Harness their Collective Wisdom and Power to Construct the Future in Co-Laboratories of Democracy, 1 ed. Greenwich, Connecticut: Information Age Publishing, 2006.

Splice for Web Service Mashups

This post plays off the previous on cloud computing. Full disclosure: I work for Xignite and helped to write Splice.



Splice is a web service mashup platform that allows you mix and mash web services. (One can think of this as combining the results from multiple web services and altering the output as desired: renaming, dropping, and restructuring the output.) The development environment is graphical meaning that you can do all this without any programming. It also has the added benefit of making web service calls in parallel where possible. Often in programming parallezing parts of a program can be difficult, so this is an important benefit. Thus one can think of Splice facilitating the customized exchange of data between systems via web services.

So how does this fit in with quantum computing? One could use it to tie together various simulation pieces to facilitate simulations across various systems.

Cloud Computing

The Horizon Report (2009) lists cloud computing as a technology taking hold in one year or less [1]. I would argue that it has taken hold already, as the article lists several examples.


How does cloud computing play into quantum computer programming? I see it as having the potential for carrying out large simulations of quantum computers. With Cove [2] I ran into memory and computation constraints pretty early on when simulating just a few handfuls of qubits. Taking advantage of multiple cores is an obvious first step, but utilizing the cloud would allow for even larger simulations. Of course the problem has to be decomposed to take advantage of the cloud, but simulations essentially boil down to multiplication between large matrices.

Of course an obvious advantage of using the cloud is the pay as you go model. Instead of building up a lab to run my simulation, I can just take advantage of the cloud and avoid the expense and overhead of setting up this lab.

References
[1] NMC. (2009). Cloud Computing - The Horizon Project, New Media Consortium, 2009. Retrieved July 21, 2009, from http://horizon.nmc.org/wiki/Cloud-Computing
[2] https://cove.purkeypile.com/