Archive for the ‘Physics’ Category

Will it quantum?

Friday, April 19th, 2013

This week Boxio et al. have put up test results on the arxiv on performing quantum annealing with more than one hundred qubits on the commercial D-Wave One device. Marketed as a quantum computer, the natural question to ask is “Will it blend?”. Or rather, is the device quantum or just a complex classical device? In their paper, the authors compare the experimental performance with a simulation of how a quantum device would perform. In addition they compare the behavior to optimized classical algorithms. The conclusion is interesting in two respects. First, the behavior of the current device seems to suggest it is a quantum device. And secondly, an improved version of the current architecture might be able to deliver real world speed ups in performing calculations with larger problem sizes. This would certainly be very interesting. Or in the words of the authors: “A quantum annealer showing better scaling than classical algorithms for these problem sizes would be an exciting breakthrough, validating the potential of quantum information processing to outperform its classical counterpart.”

Update June 5: There has been a lot of buzz about D-Wave in the aftermath of this preprint (and a related study). I highly recommend reading Scott Aaronson’s post about the topic, from which it seems that the jury is still out on whether the D-Wave architecture will provide real world benefits.

Qubit – The Game: Play your way to your next publication!

Thursday, April 4th, 2013

Update (22.05.2013): According to the Facebook page of the project, the game (now called “meQuanics”) will be released tomorrow.

Admittedly, one of the most common uses of computers is to play computer games, and in no small part did games influence the historic development of computer hardware. For example, the primary purpose of today’s high-end graphics cards is to compute the complex graphics effects of 3D games. Almost as an afterthought, it has been made possible to harness this brute computational power for productive purposes: Using frameworks such as OpenCL or CUDA, graphics cards can provide huge computational speedups in specific areas such as cryptography, molecular dynamics, fluid dynamics and distributed computing.

As far as quantum computers are concerned, some guys at the National Institute of Informatics (NII) in Tokyo believe that we can go in the opposite direction: By playing a computer game, we aid the development of error-correcting codes used for performing fault-tolerant quantum computations. The NII group is developing a mobile game whose goal is to compactify the surface codes used in topological quantum computation. To give an example, the quantum circuit on the left can be implemented by the surface code shown in the middle. The white and black “loops” in the surface code correspond to logical qubits, and quantum operations such as the CNOT-gate correspond to the braiding of the loops. For the finer details of how such codes correspond to the physical system, I refer to arXiv:1209.1441 and arXiv:1209.0510 (from which the three figures below were taken).

   quantum circuit   surface code 1   surface code 2

The code on the right shows a much compressed variant of the same underlying circuit, obtained from the code in the middle by a series of circuit-preserving transformations. One example of circuit-preserving transformations are transformations that preserve the topology of the loops and braids in the surface code, but there also exist non-trivial transformations, and the aim of the game is to minimize the volume of surface codes by performing such transformations. You can get an idea of how this will look like by viewing the trailer on the official homepage http://www.qubit-game.com or at YouTube.

Reducing the code size of important circuits, such as the ones performing purifications, has a huge potential to reduce the amount of resources (both in space and time) needed for the fault-tolerant implementation of quantum algorithms. However, little is known about the best strategies to compress surface codes, and this is where both fellow scientists and casual gamers step in: Their progress will be tracked online, thus enabling fancy stuff like score leaderboards and alerting the project managers when new compactification strategies have been discovered. Finding such strategies would be helpful for the development of compilers that automatically translate quantum algorithms into efficient surface codes with minimal overhead. Best of all, the discovery of particularly strong compactifications might earn you joint authorship in a scientific publication!

During a talk given by Simon Devitt, one of the project leaders, at CQT, I was able to try out a pre-release version of the game. The game is based on touch input, and will be available for Android- and Apple-powered phones and tablets. The 3D engine was fully working, and manipulations of the code were already possible. The roadmap is as follows: A closed beta version aimed towards the scientific community is scheduled to be released later this month. The feedback and “peer-review” from fellow researchers ensures that possible glitches (e.g. in the implementation of valid code transformations) can be spotted and fixed. Later this spring, the game will be released to the public, featuring a much refined user interface.

Simulating larger open quantum systems

Thursday, April 4th, 2013

Using numerical simulations to explore the behavior of the quantum systems we study in the lab is a great tool for gaining more understanding. Especially if you want to go beyond the abstractions that most analytically solvable descriptions are. Unfortunately simulating quantum system on a classical computer scales very badly with the complexity of the system. Even simulating the single Barium ion trapped in the neighboring lab inside a high-finesse cavity with it’s full level structure and motional states may take too long on your personal computer for you to be patient enough to wait for the results. Not to mention to try and simulate the many neutral Rubidium atoms we trap in our lab.

The Quantum Toolbox in Python (QuTiP) is quite fast out of the box for these kinds of simulations, making use of core functions compiled to C code for speed and fully utilizing the multi-core processors present in all modern computers. But you still run into the problem that computations take too long, just for systems a little bit more complex. Being written in python, QuTiP makes it quite easy to offload some off the heavy computation onto a cluster in the cloud, for example via PiCloud. Recently I wrote a short guide on how-to get started with QuTiP on PiCloud, that shows you how easy it is to push the realm of doable computations quite bit further still. Since neither better software nor having a cloud based supercomputer at your fingertips gets around the fact that simulating quantum systems on a classical computer scales miserably, we have to make do with the imposed limits. Well that is until we have a quantum computer to run these simulations on…

Dive Into Quantum Systems With Python

Wednesday, November 14th, 2012

The Quantum Optics Toolbox in Python (qutip) is a marvellous tool for simulating open quantum systems. Firstly, Robert Johansson and Paul Nation have crafted a great tool which makes it easy to explore a wide range of quantum systems. And secondly, their tool builds upon the incredible scientific python stack.

Exploring quantum systems this way is a lot of fun, but knowing where to start is sometimes a bit daunting. Recently, Robert Johansson has put up some lecture notes on github in the IPython notebook format. These let you interactively explore the functionalities of qutip. Each lecture illustrates the behaviour of a particular quantum system. The great thing about the IPython notebook format is that these lecture notes are fully executable code, which means you can play around with the examples while working through them. An ideal way to dive right into simulating quantum systems with python!

If you are completely new to the whole python way of doing things, you find some tips on how to get started at the end of this post. To see what awaits you take a look at the static versions of his lecture notes below.

On the github repository there are also PDF versions that you can download.

(more…)

Sean Barrett

Sunday, October 21st, 2012

Sean talking at the MBQC workshop in Oxford in 2007.I was greatly saddened to hear of the death of Sean Barrett on Friday morning. It seems that a taxi he was traveling in was hit by a stolen SUV, while he was on his way to a conference in Perth. I was really shocked to hear the news.

Sean is pretty known within the quantum computing community for his work on entanglement generation and on measurement based computation. Indeed, one of his papers (on double-heralding entanglement generation) was a big influence on much of my PhD research.

Sean was a great guy, friendly, lively, and very smart. His death is a great loss to the community and my thoughts are with his family and loved ones at what must be a very difficult and painful time.

Buy your experiment at Kelantan Lane

Wednesday, February 29th, 2012

Singapore is known to be a shopping mecca. But did you know, that you can buy the better part of your physics experiment in just one afternoon? No, don’t rush over to Orchard Road. You won’t find much useful stuff there. Better go down Kelantan Lane.

Street sign of Kelantan Lane

If you have never heard about Kelantan Lane, let me assure you: It’s awesome. Need some really weird screws for you latest creation? Kelantan Lane. Need to connect the piping for water cooling your latest gadget to some exotic fitting? Kelantan Lane. Need to get raw materials really quickly? Kelantan Lane. And where can you finish your shopping experience with some outstandingly good Laksa? You are right, Kelantan Lane.

If you have never been there, I suggest you take a stroll there. Kelantan Lane is a uniquely Singaporean area. It’s a cluster of lots and lots of small shops, all highly specialized in some kind of product. In fact Kelantan Lane is for experimentalists what Orchard Road is for the shopaholics. It is so nice, we regularly take visitors down there, and they love it.

Interested to find out more? Take a look at the impression below from one of our latest shooping sprees. Or contact me if you want to join our next one. To help you if you are planning a trip of your own, we compiled some of our favorite shops in the google map below. If you do know other hidden gems in the Kelantan Lane area, drop us a line and we will add it to the map.

(more…)

When physicists on the little red dot gather

Friday, February 24th, 2012

So here it is, the meeting of all physicists on the little red dot. Or as it is officially known, the IPS Meeting 2012, this year’s edition of the annual meeting of the Institute of Physics Singapore. As you can see from the program, the IPS Meeting is closely modeled after the annual meetings of bigger physical societies such as the APS in the United States of the DPG in Germany. There are exhibitors, plenary talks, invited talks, contributed talks and plenty of space for poster sessions.

So much for the theory. But will it fly? Isn’t the local physics community to small? Aren’t the topics to widespread? Isn’t there culture too different from the States or Europe? The answer to that is a clear no. Wandering through the halls of the conference venue during the coffee and lunch breaks, you will see that there is a vivid exchange of ideas. And seeing how the conference brings together physicists from all over Singapore, you are easily let to the conclusion that the IPS Meeting has no reason to fear comparison to its bigger cousins. Except for the fact that the whole conference comfortably fits into three seminar rooms and the connecting hallways.

Discussions at the IPS Meeting

Poster Session of the IPS Meeting 2012

Postdoctoral Position in Quantum Computation

Thursday, February 2nd, 2012

I’m currently looking for a postdoc to work with me here in CQT. The start date is flexible, and I’ll be considering applications until the position is filled. See below the fold for details.

If your thinking to yourself “Sure, CQT is great, but why would I want to travel so far?”, I’ll just point out that the forecast for today is 25-31°C.

(more…)

Blind quantum computing: An introduction

Friday, January 20th, 2012

Cross-posted from my personal blog.
Blind quantum computing - as illustrated by my lovely wife Liu Jia
Since I have a new paper out today in Science, which seems to have attracted the interest of a fair number of non-physicists, I thought I would take the time to explain the paper: what it is we do, and the background behind it.

The paper itself is an experimental implementation of a cryptographic scheme designed to allow a user to run a calculation on a remote computer (server) in such a way that the users input, the operations performed and the output all remain hidden from the server. In our case we care about running a computation where the remote computer is a quantum computer, but the user has access to a much more limited machine. With that in mind, I thought I might first explain the protocol before talking about the experiments themselves.

The current experiments are based on Universal Blind Quantum Computing, a protocol proposed by Anne Broadbent, Elham Kashefi and myself a few years ago (illustrated above).

In quantum computing, the basic unit of information is the quantum bit (or qubit for short). This is exactly the structure you get if you take a classical bit, which can be 0 or 1, and try to represent it as a quantum system. Quantum mechanics allows for a systems to exist in superposition. This is essentially a class of non-classical states which exists in between classical states. This means that the qubit can exist in various superpositions of 0 and 1 at the same time. Each quantum state is can be described in terms of classical states, associating two numbers with each: an absolute amplitude (between 0 and 1) which when squared gives you the probability of finding obtaining that classical state when you measure the system, and a complex phase which governs interference effects. As it turns out, this means that we can represent the state of an (unentangled) qubit very simply, as simply the point on the surface of a sphere, known as a Bloch sphere (see below).

The Bloch sphere

The classical states 0 and 1 are the top point and bottom point of the sphere, while the other states are in superposition. The lower down you go, the higher the probability of obtaining a 1 instead of a 0, with the points around the equator representing states where there is an equal probability of measuring 0 or 1.

Since we imagine this in 3 dimensional space, it makes sense to assign an X, Y and Z axis to the ball. By convention, we take the Z axis to pass through both 0 and 1, and to put the point (0,0,0) at the centre of the ball. This gives us a very easy way to visualise the basic operations of quantum computing which can be performed on a single qubit: they are simply rotations of the ball, and indeed it turns out that it is enough to consider rotations about only the X, Y and Z axes. If you can do these, you can make any more complex operation as a sequence of (3) rotations about these axes. These operations are basically a generalisation of the NOT operation a classical computer can perform, which takes 0 to 1 and 1 to 0.

As with a classical computer, we also need some way to affect one qubit dependent on the state of another qubit. As it turns out, an operation called a CZ gate is sufficient for this. The CZ gate rotates one qubit 180 degrees about the Z axis if the other qubit is in state 1, and does nothing if it is in state 0. Conveniently, this gate is symmetric, so it has exactly the same net effect independent of which qubit you designate to be rotated.

The way our protocol works is based heavily on a result which says that you can perform any computation (classical or quantum) in the following way:

  1. Prepare a sufficiently large number of qubits in the state which lies on the equator of the Bloch sphere (which specifies its absolute amplitudes) and has phase +1. I will refer to this as the + state, since in the notation most physicists use it is written as \[\frac{1}{\sqrt{2}}\mid 0 \rangle + \frac{1}{\sqrt{2}}\mid 1 \rangle\]
  2. Arrange the qubits into a regular 2D lattice (such as a square grid).
  3. For every qubit i in order:
  • Rotate i about the Z axis by some angle which depends on exactly which gate you want to perform. Note that this angle can depend on the previous measurement result.
  • Rotate i 90 degrees about the Y axis.
  • Measure whether i is 0 or 1.

We noticed that if Z rotations before and after the CZ operations have exactly the same effect, and that a Z rotation before the CZ is identical to simply preparing some other state chosen from the equator of the Bloch sphere. The idea is then to get the server to do all off the hard parts: applying the CZ gates, doing the Z rotations and making measurements, while the client only does the easy parts: computing the angle for the measurement in each round, and preparing single qubits (this last part may seem like a physically hard operation to perform, but in fact the client needs little more than a very weak laser and a pair of 3D glasses from the cinema to accomplish this if the server is sufficiently powerful).

If you look at the list of operations that the server is expected to perform, only the Z rotations actually depend on the computation being performed. This is because it is possible to choose a fixed arrangement for the qubits (the lattice referred to earlier) which will work for any computation you may wish to perform. The lattice has only 2 parameters, length and breadth, which are analogous to the time and memory the computation uses. As these parameters can be artificially inflated, they are not revealing anything particularly useful about the computation. So only the Z rotation reveals information about the computation. However, if the user prepares the initial qubits in random states on the equator of the Bloch sphere, the net rotation the server needs to perform must incorporate both the undoing of this initial random rotation and rotate by the appropriate angle required to correctly implement the desired calculation. This means that, depending on the initial random state chose (of which he is not aware), for any fixed angle required to implement the users computation, the server is equally likely to be asked to perform a Z rotation through any angle. Thus the angle he is told is completely independent of the users calculation.

So none of the classical messages the user send reveal any information about the calculation, but what about the qubits? Can’t they be measured to reveal information about their random rotation? If so, then the entire computation could be infered by the server from a combination of the classical and quantum messages sent by the user. Fortunately for us, the quantum mechanics come to the rescue. Suppose instead of choosing the inital state of the qubit and the angle sent to the server in such a way that the exactly implement the correct angle required to implement their desired computation, suppose they choose them randomly to either add up to the correct angle or add up to the correct angle + 180 degrees. What would happen then? Well, this would be the same as randomly choosing on of two opposing points on the Bloch sphere. No matter what two points you pick, it is impossible to determine either of them by making a measurement on such a system. This is because no matter what axis you pick to make a measurement along, you always have an equal chance of obtaining a 1 or a 0, independent o the choice of points. So if the user sends such randomized states to the server, together with measurement angles, there is nothing to be learned by any measurement of the system. Thus everything is perfectly hidden from a malicious server, even if they deviate from the protocol.

But doesn’t this randomization mess up the computation, resulting in nonsense? As it turns out, no, it doesn’t. This is because this extra rotation through 180 degrees is identical to flipping the measurement result the server gets when they measure the qubit. Since the measurement results are randomly flipped, the server can’t learn anything about the computation. However, the user knows whether or not the result has been flipped, and so can unflip it when they receive the result from the server. As long as they base their actions on these corrected results, the outcome of the computation is identical to if they had never occurred at all. Since the measurement results the server obtains are flipped, even for the last qubits to be measured, they have no knowledge of the outcome of the computation, though it can be trivially read by the user.

Since the server doesn’t know what computations are being performed, it is possible to set up traps to detect if the server deviates from the protocol, but this isn’t necessary to ensure blindness, and is beyond the scope of this blog post.

Now that I’ve explained the explained the theory, I’ll tell you a little about the experiment. To actually see our protocol become something real, we spent much of the last two years working with experimentalists Stefanie Barz, Philip Walther and Anton Zeilinger to find a way to implement the protocol using photons. Photons make perfect qubits, since they have two polarizations which can be used to encode a single qubit. In practical terms they would be ideal for a mature implementation of blind quantum computation, since photons can be relatively easily be transferred over large distances, allowing the user to be hundreds or thousands of kilometers distant from the server. Additionally, the group already had significant success in implementing the measurement based model of quantum computing on which our protocol is based.

Optical setup

The final set-up used (see above), like every other first demonstration, makes some compromises most notably in giving the client something a little more sophisticated than a pocket laser and 3d glasses, since this allowed us to simplify the server somewhat. None the less, it is a pretty faithful implementation of our original idea. With the 4 photonic qubits we had, we were able to hide all of the basic building blocks for a larger scale computation, meaning that we were able to demonstrate blind single and 2 qubit gates, which are sufficient to build an arbitrary computation out of. We were also able to hide instances of two quantum algorithms: the Deutsch-Josza algorithm and Grover’s algorithm.

Lastly, and most importantly, we were able to show that virtually no information could have been leaked by the apparatus. Although we have a theoretical proof, as outlined above, actual experimental apparatus aren’t as well behaved as our theoretical models, and so we need to show that our apparatus isn’t leaking information by introducing some subtle error on the quantum states. This may sound impossible, since how do you prove a negative? By running the experiment many times over for each and every possible choice user could make, we were able to use measurements made on different runs to infer the real state received by the server. This was possible because we knew exactly what the users choice of randomness was in each case, and so weren’t subject to the blindness which affects the server. With all of these measurements made, and the true states inferred, we applied a result known as Holevo’s theorem to calculate a maximum amount of information that could be extracted by a malicious server had they knowledge of the exact peculiarities of our experimental set-up. Philip and Stefanie are so good at their jobs, the system is pretty accurate, an the amount of information which could possibly have been leaked was no more than 0.169 of a bit. Even if the server could somehow learn something about the user’s desired calculation or random choices, the amount he could learn from measurements on the quantum state rises only slightly to 0.185 of a bit. In the case of these experiments, we were using 8 different initial states (i.e. 3 bits) for each blind qubit which is sufficient for any calculation, and so the amount of leakage is tiny. Not too bad for a first attempt, I think!

IPS Meeting 2012

Wednesday, January 18th, 2012

Take a look at Singapore on map and you will soon discover that you have to travel very far in order to attend any of the major physics conferences in the world. But despair not: Singapore will host it’s very own physics conference on February 23rd to 24th this year. The IPS Meeting 2012.

The IPS Meeting meeting is Singapore’s own mini version of the APS Meeting, the DPG Tagung or any other conference that aims to bring together all physicists working in a particular region. Last year’s IPS Meeting was great fun. And this year’s meeting is even to get better. Held at the Faculty of Science at NUS, the IPS Meeting 2012 will be the ideal occasion to connect with fellow physicists, present your latest work and catch up on what others are doing.

So if you are a physicists and in Singapore on February 23rd and 24th, submit your abstract by January 31st, polish your poster or slides and head over to the Faculty of Science at NUS for the IPS Meeting 2012.