Tuesday, June 29, 2010

Interview with Freedman

Here is an interview with Michael Freedman of Microsoft. Freedman is driving the effort there to create a quantum computer through the Station Q group.

It is good to see Microsoft doing some work in the field. I'd figure them to be the company to really drive research into quantum computer programming, but I've yet to come across anything that indicates they're doing so. Speaking of funding research for quantum computer (programming), given the immense payoffs that will come from when we have them, I'm constantly surprised that there isn't more work and funding in the field. (Publicly at least....)

Tuesday, June 22, 2010

Raytheon Physical Implementation Advancement

It shouldn't be too surprising given what the company is involved in, but they've made an advancement in physical implementations as outlined in their press release. The paper itself is behind a paywall here on Physical Review Letters, but luckily it is also posted here on arXiv.

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.

Wednesday, June 16, 2010

Tuesday, June 15, 2010

Quantum Information Processing with Adversarial Devices

I just came across this on arXiv: Quantum Information Processing with Adversarial Devices. This is a thesis by Matthew McKague out of the University of Waterloo.

I only skimmed the first part of it so far, but seems like some interesting work. Most quantum programming methods proposed make use of Knill's QRAM model, either explicitly or implicitly. Knill's QRAM model essentially states that a quantum computer is a slave device controlled by a classical computer. Given this, I've always pondered the possibility that something could get in between and tweak the input or output of the quantum computer. So along those lines, interesting to see this.

Thursday, June 10, 2010

Interview with Peter Shor

Here's an interview from Dr. Dobb's with Jack Woehr interviewing Peter Shor- as in Shor's algorithm for factoring. Most discussions on quantum computing focus on the physical implementations, or perhaps algorithms. It was refreshing to see a mention of actually programming quantum computers too:

JW: I've seen quantum computer machine language simulators on the web. What would an implementation of Shor's Algorithm in a high-level quantum computing language look like?

PS: Good question. Certainly I can imagine a Fortran-style high-level language that would make Shor's Algorithm easier, but really, you'd want something more high-level than that.

That being said, I don't think the best approach will be a quantum computing language. Too much computation is classical, even when a quantum computer is used. As an example, a quantum computer is used just for a single step of Shor's algorithm- the rest is classical. Preferable to a quantum computing language I think would be a framework that extends classical languages to allow for quantum computation. There are many benefits, but I see the big two as being:

  1. The framework designer can focus on tackling quantum computation. They don't have to try to include classical techniques that we've spent decades refining.
  2. There is a large user base for the popular classical languages. By creating a framework there is less of a hurdle for those programmers to perform quantum computation. Furthermore it will integrate much better with existing code bases.
Of course, I developed Cove as a framework for quantum computation exactly because of the reasons above.

Monday, June 7, 2010

Geometry of abstraction in quantum computation

I came across this paper by Dusko Pavlovic posted on arXiv over the weekend: Geometry of abstraction in quantum computation. Here's the abstract:

Quantum algorithms are sequences of abstract operations, performed on non-existent computers. They are in obvious need of categorical semantics. We present some steps in this direction, following earlier contributions of Abramsky, Coecke and Selinger. In particular, we analyze function abstraction in quantum computation, which turns out to characterize its classical interfaces. Some quantum algorithms provide feasible solutions of important hard problems, such as factoring and discrete log (which are the building blocks of modern cryptography). It is of a great practical interest to precisely characterize the computational resources needed to execute such quantum algorithms. There are many ideas how to build a quantum computer. Can we prove some necessary conditions? Categorical semantics help with such questions. We show how to implement an important family of quantum algorithms using just abelian groups and relations.

Wednesday, June 2, 2010

Adoption Issues for Quantum Information Technology

Pascal Heus (at George Mason) is doing work on adoption issues for quantum information technlogy which he describes as:

This research project aims at better understanding the challenges facing Quantum Information Technology (QIT) in order to successfully integrate into the existing "classic" Information Technology (IT) framework.

You can read more about it on his site here. He also has a survey on the topic here, which I thought was good. I recommend taking the few minutes to do it if you have the time.

LED for Entangled Light

Toshiba has created an "entangled light emitting diode" (ELED) which can create entangled photons. Maybe the optical approach towards quantum computing will be viable. You can read more at the ABC News article.