Its Quantum Computing

Qbit–What it is ?

2012-04-10T23:36:00.001+05:30

In quantum computing, a qubit or quantum bit is a unit of quantum information—the quantum analogue of the classical bit—with additional dimensions associated to the quantum properties of a physical atom. The physical construction of a quantum computer is itself an arrangement of entangled atoms, and the qubit represents both the state memory and the state of entanglement in a system. A quantum computation is performed by initializing a system of qubits with a quantum algorithm —"initialization" here referring to some advanced physical process that puts the system into an entangled state.

The qubit is described by a quantum state in a two-state quantum-mechanical system, which is formally equivalent to a two-dimensional vector space over the complex numbers. One example of a two-state quantum system is the polarization of a single photon: here the two states are vertical polarization and horizontal polarization. In a classical system, a bit would have to be in one state or the other, but quantum mechanics allows the qubit to be in a superposition of both states at the same time, a property which is fundamental to quantum computing.

Bit versus qubit

A bit is the basic unit of computer information. Regardless of its physical realization, a bit is always understood to be either a 0 or a 1. An analogy to this is a light switch— with the off position representing 0 and the on position representing 1.

A qubit has some similarities to a classical bit, but is overall very different. Like a bit, a qubit can have two possible values—normally a 0 or a 1. The difference is that whereas a bit must be either 0 or 1, a qubit can be 0, 1, or a superposition of both.

Representation

The two states in which a qubit may be measured are known as basis states (or basis vectors). As is the tradition with any sort of quantum states, Dirac, or bra-ket notation, is used to represent them. This means that the two computational basis states are conventionally written as and (pronounced "ket 0" and "ket 1").

Qubit states

Bloch sphere representation of a qubit. The probability amplitudes in the text are given by and .

A pure qubit state is a linear superposition of the basis states. This means that the qubit can be represented as a linear combination of and :

where α and β are probability amplitudes and can in general both be complex numbers.

When we measure this qubit in the standard basis, the probability of outcome is and the probability of outcome is . Because the absolute squares of the amplitudes equate to probabilities, it follows that α and β must be constrained by the equation

simply because this ensures you must measure either one state or the other.

Bloch Sphere

The possible states for a single qubit can be visualised using a Bloch sphere (see diagram). Represented on such a sphere, a classical bit could only be at the "North Pole" or the "South Pole", in the locations where and are respectively. The rest of the surface of the sphere is inaccessible to a classical bit, but a pure qubit state can be represented by any point on the surface. For example the pure qubit state would lie on the equator of the sphere, on the positive y axis.

The surface of the sphere is two-dimensional space, which represents the state space of the pure qubit states. This state space has two local degrees of freedom. It might at first sight seem that there should be four degrees of freedom, as α and β are complex numbers with two degrees of freedom each. However, one degree of freedom is removed by the constraint . Another, the overall phase of the state, has no physically observable consequences, so we can arbitrarily choose α to be real, leaving just two degrees of freedom.

It is possible to put the qubit in a mixed state, a statistical combination of different pure states. Mixed states can be represented by points inside the Bloch sphere.

Operations on pure qubit states

There are various kinds of physical operations that can be performed on pure qubit states.^{[citation needed]}

A quantum logic gate can operate on a qubit: mathematically speaking, the qubit undergoes a unitary transformation. Unitary transformations correspond to rotations of the Bloch sphere.
Standard basis measurement is an operation in which information is gained about the state of the qubit. The result of the measurement will be either , with probability , or , with probability . Measurement of the state of the qubit alters the values of α and β. For instance, if the result of the measurement is , α is changed to 1 (up to phase) and β is changed to 0. Note that a measurement of a qubit state entangled with another quantum system transforms a pure state into a mixed state.

Entanglement

An important distinguishing feature between a qubit and a classical bit is that multiple qubits can exhibit quantum entanglement. Entanglement is a nonlocal property that allows a set of qubits to express higher correlation than is possible in classical systems. Take, for example, two entangled qubits in the Bell state

In this state, called an equal superposition, there are equal probabilities of measuring either or , as .

Imagine that these two entangled qubits are separated, with one each given to Alice and Bob. Alice makes a measurement of her qubit, obtaining—with equal probabilities—either or . Because of the qubits' entanglement, Bob must now get exactly the same measurement as Alice; i.e., if she measures a , Bob must measure the same, as is the only state where Alice's qubit is a .

Entanglement also allows multiple states (such as the Bell state mentioned above) to be acted on simultaneously, unlike classical bits that can only have one value at a time. Entanglement is a necessary ingredient of any quantum computation that cannot be done efficiently on a classical computer.

Many of the successes of quantum computation and communication, such as quantum teleportation and superdense coding, make use of entanglement, suggesting that entanglement is a resource that is unique to quantum computation.

Quantum register

A number of entangled qubits taken together is a qubit register. Quantum computers perform calculations by manipulating qubits within a register. A qubyte is a collection of eightentangled qubits. It was first demonstrated by a team at the Institute of Quantum Optics and Quantum Information at the University of Innsbruck in Austria in December 2005.

Variations of the qubit

Similar to the qubit, a qutrit is a unit of quantum information in a 3-level quantum system. This is analogous to the unit of classical information trit. The term "qudit" is used to denote a unit of quantum information in a d-level quantum system. A quiet qubit refers to a qubit that can be efficiently decoupled from the environment.

Physical representation

Any two-level system can be used as a qubit. Multilevel systems can be used as well, if they possess two states that can be effectively decoupled from the rest (e.g., ground state and first excited state of a nonlinear oscillator). There are various proposals. Several physical implementations which approximate two-level systems to various degrees were successfully realized. Similarly to a classical bit where the state of a transistor in a processor, the magnetization of a surface in a hard disk and the presence of current in a cable can all be used to represent bits in the same computer, an eventual quantum computer is likely to use various combinations of qubits in its design.

Part of a series on "Quantum computing for the determined".

Qubit storage

In a paper entitled: "Solid-state quantum memory using the ³¹P nuclear spin," published in the October 23, 2008 issue of the journal Nature,an international team of scientists that included researchers with the U.S. Department of Energy's Lawrence Berkeley National Laboratory (Berkeley Lab) reported the first relatively long (1.75 seconds) and coherent transfer of a superposition state in an electron spin "processing" qubit to a nuclear spin "memory" qubit. This event can be considered the first relatively consistent quantum Data storage, a vital step towards the development of quantum computing.

Origin of the concept and term

The concept of the qubit was unknowingly introduced by Stephen Wiesner in 1983, in his proposal for unforgeable quantum money, which he had tried to publish for over a decade.

The coining of the term "qubit" is attributed to Benjamin Schumacher. In the acknowledgments of his paper, Schumacher states that the term qubit was invented in jest (due to its phonological resemblance with an ancient unit of length called cubit), during a conversation with William Wootters. The paper describes a way of compressing states emitted by a quantum source of information so that they require fewer physical resources to store. This procedure is now known as Schumacher compression.

Upper bounds on fault tolerance thresholds of noisy Clifford-based quantum computers

2010-08-28T07:43:00.004+05:30

Abstract:
We consider the possibility of adding noise to a quantum circuit to make it efficiently simulatable classically. In previous works this approach has been used to derive upper bounds to fault tolerance thresholds - usually by identifying a privileged resource, such as an entangling gate or a non-Clifford operation, and then deriving the noise levels required to make it `unprivileged'. In this work we consider extensions of this approach where noise is added to Clifford gates too, and then `commuted' around until it concentrates on attacking the non-Clifford resource. While commuting noise around is not always straightforward, we find that easy instances can be identified in popular fault tolerance proposals, thereby enabling sharper upper bounds to be derived in these cases. For instance we find that if we take Knill's high threshold proposal together with the ability to prepare any possible state in the $XY$ plane of the Bloch sphere, then no more than 3.69% error-per-gate noise is sufficient to make it classical, and 13.71% of Knill's gamma noise model is sufficient. These bounds have been derived without noise being added to the decoding parts of the circuits. Introducing such noise in a toy example suggests that the present approach can be optimised further to yield tighter bounds.

Quantum Algorithms A Different View

2010-08-27T14:01:00.004+05:30

A view of quantum algorithms via linear algebra

David Hilbert is famous, beyond famous. He is one of the greatest mathematicians of all time. I wish to quote him on theories:

A mathematical theory is not to be considered complete until you have made it so clear that you can explain it to the first man whom you meet on the street.

Algorithms Not Physics

My goal was to remove QA’s from any physical considerations. If this offends the quantum experts, then I am sorry. No I am not sorry. I think we need to do this to make progress.

We have done this decoupling almost completely with classical algorithms. When we explain a new classical algorithm we talk about high level operations—we do not talk about transistors and wires. Nor gates and memory cells. I would venture that few theorists could explain the details of how an L2 cache works, or how a modern arithmetic unit does pipelining, or in general how processors really work. The beautiful point is, it just does not matter for most of theory.

It is this ability to think at a high level for the creation and analysis of classical algorithms that, I believe, is the reason theory has been able to create such powerful algorithms. These algorithms are often described at a level way above any implementation details. I believe this is fundamental, and one of the cornerstones of why theory works.

Here are two classical algorithms: RSA Encryption and the Number Field Sieve (NFS). Both have changed the world, and were on Dick Karp’s list at the last Theory Day at Tech as great algorithms. Neither is described at a low level. For example, RSA is usually described in terms of operations on large integers—each of these operations requires millions of binary operations to perform. NFS is described also at a very high level. Without this ability I doubt that either algorithm would have been discovered.

I think that to make radical progress on QA’s we need to move away from a bit-level understanding and analysis and move to a high-level understanding. This is what I tried to supply in the previous post on quantum algorithms. If I failed in that goal, I apologize to you, but I believe that this goal is the right one. Perhaps someone else will be able to succeed in raising the level of detail—I hope so.

Geometry Not Quantum Mechanics

In that previous discussion I tried to make the assumptions needed to understand the Deutsch algorithm as simple as possible. This was to help a non-expert to “see” what was happening without any quantum mechanics details. I also believe that by stripping away tensor products, qubits, Hadamard Transforms, and all the rest we could lay bare what is really happening. I agree that none of these concepts are too difficult, but are they essential to make a person have a “feel” for what is happening with QA’s? I do not believe that they are.

I also hope that this view can be used by theory experts to make further progress on QA’s. If the details are pushed aside and all that is left is a simple question about unit vectors on the sphere, then I hope that we might be able to find new insights. I am working right now on doing this, and I believe that I may succeed. If QA are “just” questions about geometry, then I assert that we may be able to find new QA’s or prove new lower bounds. I still believe that is true.

Grover’s Algorithm

Lov Grover discovered one of the most important QA known in 1996. Or is that “invented?” The algorithm named after him is able to search a space of size in cost . Of course, this is much faster than any classical algorithm, which would take linear time, even for random algorithms.

Grover’s beautiful result has many applications. You can think of his algorithm as allowing the computation of an sized “OR” in time square root of . This is so general that it has had many applications in various areas of complexity. For example, it can be used to perform triangle detection faster than any known classical method—see the beautiful paper by Frederic Magniez, Miklos Santha, and Mario Szegedy.

It should be noted in this and many other applications there are nice interactions between Grover and standard methods. That is, the optimal results often follow from a “clever” use of Grover’s algorithm.

The Linear Algebra View

Let me explain Grover’s algorithm using just linear algebra. We begin in a state of not knowing anything about the space of possible solutions— is the all- vector, but divided by to make it a unit vector. Let us suppose there are solutions. We do not know in advance. However, we will argue that it is enough to know to within a factor of . Then we will apply the standard idea of first trying , then , then and so on, and this will not affect the order of the running time. So we may suppose is known after all—and what we really do not know is the location of the solutions. Our goal state is the vector that has a in those positions that belong to , and elsewhere, this time dividing by to make a unit vector .

All states that we reach along the way will be linear combinations of our initial ignorance state and the unknown full-knowledge state , that is

where to preserve a unit vector. Initially we have , . When we measure, the chance of getting the index of a solution is . Initially this is just , which is just the chance of guessing a solution at random. If is high, however, then we stand a good chance of getting a solution. So that’s the goal of Grover’s algorithm—to stay in the simple two-dimensional subspace spanned by and , while moving from close enough to for a measurement to give a solution with high probability. We just need some operations that keep this subspace fixed but move points well enough inside it.

The first operation is an by matrix that is the identity matrix—except that the diagonal entries corresponding to solutions are instead of . That is, . This matrix is given as a “black box”—we are not allowed to inspect it. It really represents the verification predicate that an element is a solution. Since , clearly is unitary. The second operation is simply the matrix

where is the all matrix. Each row has one entry of and entries of . Its norm is therefore

All pairs of different rows have dot product . So is also a unitary matrix. To verify that these operations conserve the subspace , note that while , and compute:

The algorithm then simply computes

where . Then, it measures the vector . The claim is with high probability the measurement yields some index so that .

Grover Analysis

The key here is to prove that the algorithm works: that is after applying the matrix about square root of times the measurement yields a solution with high probability. Given our insight about preserving a two-dimensional subspace, this comes down to simple linear algebra on matrices. The algebra is the same as on Wikipedia’s page on Grover’s algorithm for the case , except we replace factors by .

We can see intuitively from the above action of and on and that effects a rotation through an angle of , which is roughly when is small relative to . Starting from which is the point in this co-ordinate system, it takes about iterations to get near the point . We get near within distance about , in fact, and the error when measuring is hence order-of the square of that, i.e. only order . Note that as it iterates, the algorithm gets progressively closer to its goal—in the sense that if “Simon says: measure” at any time, its chance of finding a solution always improves.

Finally, as we noted above, if we do not know then we make a “net” by guessing then then and so on. When our “” is off by a factor of 2 we will not get so near to the point . However, there will be multiple iterations for values in our net that are close enough to give a reasonable success probability. The full analysis involves a tradeoff between random guessing working well when is large, versus the error being small when is small, and repeating some measurement trials to make the net a little finer than stepping down by factors of . The details need to be worked out, but these details are not quantum mechanical—they are ordinary theory-of-algorithms details.

Open Problems

The goal here was not to supplant the current view of QA’s. Nor was it to not teach all the details to our students. The goal was both less and more important. It was to start to try to create a way to look at QA’s that was simpler, more accessible to many. And at the same time could lead us to discover new insights into QA’s. I believe that the more ways we can define and view a mathematical topic, the better is our understanding.

I hope that I helped in this regard. In any event thanks to all who read that discussion and this one. Thanks for being supportive—even those who disagree with this approach.

Photon Triplets Generated

2010-08-04T09:53:00.002+05:30

An international research team achieved a longstanding milestone in quantum optics research — the direct generation of photon triplets. This result has been sought for years but never achieved until now.

An illustration of the triple photon experiment. (Image: Institute For Quantum Computing)

The breakthrough was made by Thomas Jennewein, Hannes Hübel, Deny Hamel and Kevin Resch of the University of Waterloo, along with Alessandro Fedrizzi of the University of Queensland and Sven Ramelow of the Austrian Academy of Sciences.
“This is going to open a new frontier of quantum optics and allow a new class of experiments in quantum computing using photons,” said lead investigator Jennewein.
In the past, the generation of pairs of photons (particles of light) revolutionized quantum optics and made possible emerging technologies such as quantum cryptography and quantum computing with photons.
Typically, these photon pairs were created from strong lasers sent through a crystal - a process known as “parametric down-conversion.”
In the new approach, researchers created photon triplets by producing a first pair of photons using an optical crystal, then splitting one of the photon pairs further into two additional photons inside a second crystal.
It’s a process that was first conceived 20 years ago, but had never before been experimentally observed.
Because each triplet originates from a single pump photon, the quantum correlations will extend over all three photons in a manner not achievable when using independently created photon pairs.
It is expected that this photon-triplet source will allow tests of novel quantum correlations and will greatly advance photonic quantum computing.
Jennewein praised his collaborators and IQC’s research facilities for the fruitful results: “It shows the value of a very strong team and a great environment for allowing breakthroughs to happen.”
In the research featured in the latest issue of the journal Nature, the researchers explain that these tripartite quantum correlations will significantly advance quantum information research.
The project involved collaboration between IQC’s Quantum Photonics Laboratory and Quantum Optics and Quantum Information Group.
The research was supported by the Canadian Institute for Advanced Research, the Ontario Centers of Excellence, the Ontario Ministry of Research and Innovation, the Natural Sciences and Engineering Council of Canada, and the Canadian Foundation for Innovation.

[1007.3624] Unbounded-error quantum computation with small space bounds

2010-07-28T17:12:00.001+05:30

Authors: Abuzer Yakaryilmaz, A. C. Cem Say

(Submitted on 21 Jul 2010)

Abstract: We prove the following facts about the language recognition power of quantum Turing machines (QTMs) in the unbounded error setting: QTMs are strictly more powerful than probabilistic Turing machines for any common space bound $ s $ satisfying $ s(n)=o(\log \log n) $. For "1.5-way" Turing machines, where the input tape head is not allowed to move left, the above result holds for $s(n)=o(\log n) $. We also give a characterization for the class of languages recognized with unbounded error by one-way quantum finite automata (QFAs) with restricted measurements. It turns out that these automata are equal in power to their probabilistic counterparts, and this fact does not change when the QFA model is augmented to allow general measurements and mixed states. Unlike the case with classical finite automata, when the QFA tape head is allowed even 1.5-way movement, more languages become recognizable. We define and use a QTM model that generalizes the other variants introduced earlier in the study of quantum space complexity.

Comments:
A preliminary version of this paper appeared in the Proceedings of the Fourth International Computer Science Symposium in Russia, pages 356--367, 2009

[1007.3624] Unbounded-error quantum computation with small space bounds

Download:

This remarkable "ion trap" turns charged atoms into quantum information carriers

2010-07-12T16:55:00.001+05:30

A new device uses optical fibers to measure light from individual ions. Since these charged atoms store quantum information, this ion trap could allow us to build practical quantum computers and to link light and matter at the quantum level.

The real stumbling block for quantum computers is finding something that can practically be used to house a qubit, the building blocks of quantum information. This ion trap makes the electrically charged atoms a genuine possibility by isolating each one and making possible the extraction of individual qubits of information. In fact, the researchers were able to use them in some very rudimentary experimental quantum computing.

So how does it work? The device is just one square millimeter in size and has a built-in optical fiber. Tiny electrodes are used to trap the ions that pass through it within 30 to 50 micrometers below the surface of the device. The ion is then within reading distance of the optical fiber, which detects the ion's fluorescence signals and uses that data to figure out the ion's quantum information content.

Previous attempts to read the fluorescence of ions have depended on external lenses located about 5 centimeters away. That may not sound like much, but it's a full 500 times further away from the ions than the fiber needs to be, which means the detection system can be miniaturized and packed in on a level never before imagined. A huge number of these fibers could be put on a single quantum computer chip, which just wouldn't be possible with the older lens system. The fiber method isn't as efficient as its lens counterpart, although its developers are confident they can improve the light absorption of the device. Either way, since ions give off millions of photos per second, they are plenty bright enough for the fibers to detect and read.

For this particular trap design, the researchers ultimately hope to pair individual photons with individual ions. That would allow information to be swapped from matter qubits to photon qubits. Matter qubits, like those using ions, are currently the preferred foundation of quantum computers, while photon qubits are used for quantum communications, which is thought to be the most secure form of communication possible. By linking data between the two types of qubits, the developers could set up a system that would bring together quantum computers and quantum communications networks.

Unusual quantum states may shake up quantum computing

2010-07-05T17:12:00.001+05:30

Researchers have found a new method of controlling the quantum states of solid particles, and the research could enable a different approach to quantum computing, according to a paper published in Nature.

Using doped silicon, scientists found that they were able to exert control over the solid atoms using terahertz frequency radiation, getting the atoms to oscillate between states normally found in hydrogen atoms. While the equipment they used was very specialized, the authors hope that this new level of coherent control will allow for a different style of entanglement, as well as finer manipulation of quantum information held in excited atoms.

Scientists have had a field day using lasers to perform all manner of quantum manipulations on various particles: trapping photons, entangling them, and sending them over long distances, even using this to perform simple quantum calculations. However, these quantum states are often unstable and hard to control, creating errors and unreliability in their information and in the calculations they perform.

To help fix this, a group of researchers are pursuing the use of well-known quantum states, called Rydberg states, using atoms in a solid. These states follow the rules of a formula that was designed to explain free hydroden atoms, but a special physical loophole allows larger atoms to be obey the formula, too.

Atoms that can be manipulated in Rydberg states have an interesting property: their ground states are too compact to interact with each other. If two such atoms were used for quantum computing, they could be entangled only in their excited states, leaving their ground states independent. This could provide a new quantum information relay method.

A material's impurities can occupy Rydberg states if they have exactly one more valence electron than the host material. Phosphorus-doped silicon, a common type of semiconductor, fits the bill perfectly. The researchers behind the new paper decided they would use radiation in the terahertz range on the phosphorus impurities, hoping that the fine oscillations would let them switch the atoms between two closely spaced Rydberg states.

In order to prove they were actually exerting control over the phosphorus at a quantum level, the researchers had to look for two kinds of activity in the atoms. One was Rabi oscillations, a set of waves that indicate the atom is being driven between a ground and an excited state by the laser. If the laser was set to the right frequency, it would create a superposition of the ground and excited wavefunctions that emits a simple, easily detected wavepacket that oscillates over time.

The other thing they needed to find was photon echoes from the particles. An echo comes from putting a set of particles into a coherent state by zapping them with a laser, then letting their wave functions evolve over time. A second laser pulse would reverse the evolution and cause the particles to send out an extra "echo" of energy.

Packed into the echo is a record of the environment's effects on the atom—a sort of "while you were away" note to would-be observers. Reading the echo would allow researchers to figure out exactly how long the wavefunctions of the atoms would take to "dephase," or get all confused by environmental effects. That length of time is a stand-in measure for how resilient the wavefunctions are, and how long they could be used to hold or transfer quantum information.

Using the Free Electron Laser for Infrared Experiments (FELIX) in the Netherlands, the researchers were able to create laser pulses that exerted remarkable, and remarkably fast, control over the phosphorus atoms. At terahertz frequencies, they were able to stimulate both Rabi oscillations and photon echoes. The Rabi oscillations indicated a superposition of the atoms' ground and first excited states, and had energies that corresponded to the Rydberg series they were looking for.

The photon echoes that the atoms generated indicated that they had a dephasing time of 160 picoseconds. This sounds too short to get much of anything accomplished, but the electrons in the phosphorus atoms were oscillating between states every 100 femtoseconds. If the atom were carrying information, theoretically this means users have over a thousand opportunities to read the atom before its wavefunction gets too distorted to use.

Going forward, the authors of the paper seemed most interested in the prospects for entangling pairs of Rydberg-capable impurities. A Bell state where each atom's ground state is entangled with the other's excited state sounds particularly interesting, since reading one of the atoms has only a chance of setting the other. Aside from that, the researchers hope their new method for exerting coherent control over the quantum states of a solid, widely used material will introduce a bit more versatility to the field of quantum computing.

First Ever Quantum Memory Storage

2010-06-28T18:56:00.001+05:30

A team of researchers from the Australian National University (ANU) has developed the most efficient quantum memory for light in the world, making the future of super-fast computing and communications one step closer to reality, according to press release from the ANU.

The researchers from the ANU Research School of Physics and Engineering deployed a technique they pioneered that allows them to manipulate light from a laser, controlling the electrons in a super-chilled crystal at -270 degrees Celsius. Lead researcher Morgan Hedges explains how it works:

Light entering the crystal is slowed all the way to a stop, where it remains until we let it go again. When we do let it go, we get out essentially everything that went in as a three-dimensional hologram, accurate right down to the last photon.

Because of the inherent uncertainty in quantum mechanics, some of the information in this light will be lost the moment it is measured, making it a read-once hologram. Quantum mechanics guarantees this information can only be read once, making it perfect for secure communication.

The memory has incredible accuracy and efficiency qualities never seen before, making it a leading candidate for quantum computing which would be far more powerful than today’s computing technology.

The team’s experiment ‘stopped’ light in a crystal for over a second, more than 1,000 times longer than was previously possible, according to team leader Dr Matthew Sellars. Now they are working on a system with higher efficiency which could store information for hours.

Michael Nielsen at Singularity Summit 2009 -- Quantum Computing Part 1

2010-06-09T11:43:00.001+05:30

Scientists make quantum computing breakthrough - LED is key to making entangled light

2010-06-09T11:37:00.001+05:30

Scientists at the University of Cambridge and Toshiba Research Europe have made a monumental breakthrough in quantum computing with new LEDs.
The duo announced the invention of the Entangled Light Emitting Diode and plan to release a paper on it in the science journal Nature later today.
The head of the project at Toshiba Research Europe, Dr. Andrew Shields, said: “Although entangled light has been produced previously by shining an intense laser beam on crystals, the new simple device is the first voltage-powered source. The discovery is significant because it will allow electrical addressing of many entangled light emitters on a single chip, opening the path to ultra-powerful semiconductor processors based on quantum computation.”
The ELED is based on standard LEDs used in current technology, such as traffic lights and the power indicators on most computers, meaning they can be produced quickly and cheaply for a mass market. The big difference, however, is that the ELEDs contain a nanometer-scale region of semiconductor which scientists call a quantum dot. This turns the conventional current into entangled light, opening many new avenues for quantum computing.

“For successful operation it was essential to optimize the thickness of the semiconductor material surrounding the quantum dot to control the supply of current to the dot,” said Senior Research Scientist Dr. Mark Stevenson. “In addition the properties of the dot itself had to be carefully tailored to produce entangled emission.”
This entangled light is necessary to make a quantum computer, which will be able to perform tasks well beyond the scope of current computer technology. Examples given by the scientists include modeling new pharmaceuticals or materials, communicating securely via quantum cryptography, and producing higher storage on optical disks.

Quantum Computing- layman view

2010-06-09T11:36:00.003+05:30

Imagine a computer whose memory is exponentially larger than its apparent physical size; a computer that can manipulate an exponential set of inputs simultaneously; a computer that computes in the twilight zone of space. You would be thinking of a quantum computer. Relatively few and simple concepts from quantum mechanics are needed to make quantum computers a possibility. The subtlety has been in learning to manipulate these concepts. Is such a computer an inevitability or will it be too difficult to build?

By the strange laws of quantum mechanics, Folger, a senior editor at Discover, notes that; an electron, proton, or other subatomic particle is “in more than one place at a time,” because individual particles behave like waves, these different places are different states that an atom can exist in simultaneously.

What’s the big deal about quantum computing? Imagine you were in a large office building and you had to retrieve a briefcase left on a desk picked at random in one of hundreds of offices. In the same way that you would have to walk through the building, opening doors one at a time to find the briefcase, an ordinary computer has to make it way through long strings of 1’s and 0’s until it arrives at the answer. But what if instead of having to search by yourself, you could instantly create as many copies of yourself as there were rooms in the building all the copies could simultaneously peek in all the offices, and the one that finds the briefcase becomes the real you, the rest just disappear. – (David Freeman, discover )

David Deutsch, a physicist at Oxford University, argued that it may be possible to build an extremely powerful computer based on this peculiar reality. In 1994, Peter Shor, a mathematician at AT&T Bell Laboratories in New Jersey, proved that, in theory at least, a full-blown quantum computer could factor even the largest numbers in seconds; an accomplishment impossible for even the fastest conventional computer. An outbreak of theories and discussions of the possibility of building a quantum computer now permeates itself though out the quantum fields of technology and research.

It’s roots can be traced back to 1981, when Richard Feynman noted that physicists always seem to run into computational problems when they try to simulate a system in which quantum mechanics would take place. The calculations involving the behavior of atoms, electrons, or photons, require an immense amount of time on today’s computers. In 1985 in Oxford England the first description of how a quantum computer might work surfaced with David Deutsch’s theories. The new device would not only be able to surpass today’s computers in speed, but also could perform some logical operations that conventional ones couldn’t.

This research began looking into actually constructing a device and with the go ahead and additional funding of AT&T Bell Laboratories in Murray Hill, New Jersey a new member of the team was added. Peter Shor made the discovery that quantum computation can greatly speed factoring of whole numbers. It’s more than just a step in micro-computing technology, it could offer insights into real world applications such as cryptography.

“There is a hope at the end of the tunnel that quantum computers may one day become a reality,” says Gilles Brassard of University of Montreal. Quantum Mechanics give an unexpected clarity in the description of the behavior of atoms, electrons, and photons on the microscopic levels. Although this information isn’t applicable in everyday household uses it does certainly apply to every interaction of matter that we can see, the real benefits of this knowledge are just beginning to show themselves.

In our computers, circuit boards are designed so that a 1 or a 0 is represented by differing amounts of electricity, the outcome of one possibility has no effect on the other. However, a problem arises when quantum theories are introduced, the outcomes come from a single piece of hardware existing in two separate realities and these realties overlap one another affecting both outcomes at once. These problems can become one of the greatest strengths of the new computer however, if it is possible to program the outcomes in such a way so that undesirable effects cancel themselves out while the positive ones reinforce each other.

This quantum system must be able to program the equation into it, verify it’s computation, and extract the results. Several possible systems have been looked at by researchers, one of which involves using electrons, atoms, or ions trapped inside of magnetic fields, intersecting lasers would then be used to excite the confined particles to the right wavelength and a second time to restore the particles to their ground state. A sequence of pulses could be used to array the particles into a pattern usable in our system of equations.

Another possibility by Seth Lloyd of MIT proposed using organic-metallic polymers (one dimensional molecules made of repeating atoms). The energy states of a given atom would be determined by it’s interaction with neighboring atoms in the chain. Laser pulses could be used to send signals down the polymer chain and the two ends would create two unique energy states.

A third proposal was to replace the organic molecules with crystals in which information would be stored in the crystals in specific frequencies that could be processed with additional pulses. The atomic nuclei, spinning in either of two states (clockwise or counterclockwise) could be programmed with a tip of a atomic microscope, either “reading” it’s surface or altering it, which of course would be “writing” part of information storage. “Repetitive motions of the tip, you could eventually write out any desired logic circuit, ” DiVincenzo said.

This power comes at a price however, in that these states would have to remain completely isolated from everything, including a stray photon. These outside influences would accumulate, causing the system to wander off track and it could even turn around and end up going backward causing frequent mistakes. To keep this from forming new theories have arisen to overcome this. One way is to keep the computations relatively short to reduce chances of error, another would be to restore redundant copies of the info on separate machines and take the average (mode) of the answers.

This would undoubtedly give up any advantages to the quantum computer, and so AT&T Bell Laboratories have invented an error correction method in which the quantum bit of data would be encoded in one of nine quantum bits. If one of the nine were lost it would then be possible to recover the data from what information did get through. This would be the protected position that the quantum state would enter before being transmitted. Also since the states of the atoms exist in two states, if one were to be corrupted the state of the atom could be determined simply by observing the opposite end of the atom since each side contains the exact opposite polarity.

The gates that would transmit the information is what is mainly focused on by researchers today, this single quantum logic gate and it’s arrangement of components to perform a particular operation. One such gate could control the switch from a 1 to a 0 and back, while another could take two bits and make the result 0 if both are the same, 1 if different.

These gates would be rows of ions held in a magnetic trap or single atoms passing through microwave cavities. This single gate could be constructed within the next year or two yet a logical computer must have the millions of gates to become practical. Tycho Sleator of NYU and Harald Weinfurter of UIA look at the quantum logic gates as simple steps towards making a quantum logic network.

These networks would be but rows of gates interacting with each other. Laser beams shining on ions cause a transition from one quantum state to another which can alter the type of collective motion possible in the array and so a specific frequencies of light could be used to control the interactions between the ions. One name given to these arrays has been named “quantum-dot arrays” in that the individual electrons would be confined to the quantum-dot structures, encoding information to perform mathematical operations from simple addition to the factoring of those whole numbers.

The “quantum-dot” structures would be built upon advances in the making of microscopic semiconductor boxes, whose walls keep the electrons confined to the small region of material, another way to control the way information is processed. Craig Lent, the main researcher of the project, base this on a unit consisting of five quantum dots, one in the center and four and at the ends of a square, electrons would be tunneled between any of the two sites.

Stringing these together would create the logic circuits that the new quantum computer would require. The distance would be sufficient to create “binary wires” made of rows of these units, flipping the state at one end causing a chain reaction to flip all the units states down along the wire, much like today’s dominoes transmit inertia. Speculation on the impact of such technology has been debated and dreamed about for years.

In the arguing points, the point that it’s potential harm could be that the computational speed would be able to thwart any attempts at security, especially the now NSA’s data encryption standard would be useless as the algorithm would be a trivial problem to such a machine. On the latter part, this dreamed reality first appeared in the TV show Quantum Leap, where this technology becomes readily apparent when Ziggy –the parallel hybrid computer that he has designed and programmed– is mentioned, the capabilities of a quantum computer mirror that of the show’s hybrid computer.

Quantum Architectures: Quantum Circuit Viewer

2010-06-09T11:36:00.001+05:30

QASM is a simple text-format language for describing acyclic quantum circuits composed from single qubit, multiply controlled single-qubit gates, multiple-qubit, and multiple-qubit controlled multiple-qubit gates.
qasm2circ is a package which converts a QASM file into a graphical depiction of the quantum circuit, using standard quantum gate symbols (and other user-defined symbols). This is done using latex (specifically, xypic), to produce high-quality output in epsf, pdf, or png formats.
Figures of quantum circuits in the book "Quantum Computation and Quantum Information," by Nielsen and Chuang, were produced using an earlier version of this package.
Download distribution here (zip) or (tgz) (the distribution includes all the examples).

Current version = 1.4 (Released 14-Mar-05)
[ home | Example 1 | Example 2 | Example 3 | Example 4 | Example 5 | Example 6 | Example 7 | Example 8 | Example 9 | Example 10 | Example 11 | Example 12 | Example 13 | Example 14 | Example 15 | Example 16 | Example 18 | Example 17 | qasm specification | Installation instructions ]

QASM Specification

QASM instructions are as follows. Lines begining with '#' are comments. All other lines should be of the form op args where op-args pairs are:

qubit   name,initval
cbit    name,initval
measure qubit
H       qubit
X       qubit
Y       qubit
Z       qubit
S       qubit
T       qubit
nop     qubit
zero    qubit
discard qubit
slash   qubit
dmeter  qubit
cnot    ctrl,target
c-z     ctrl,target
c-x     ctrl,target
toffoli ctrl1,ctrl2,target
ZZ      b1,b2
SS      b1,b2
swap    b1,b2
Utwo    b1,b2
space   qubit
def     opname,nctrl,texsym
defbox  opname,nbits,nctrl,texsym

Where:

def     - define a custom controlled single-qubit operation, with
opname  = name of gate operation
nctrl   = number of control qubits
texsym  = latex symbol for the target qubit operation
defbox  - define a custom muti-qubit-controlled multi-qubit operation, with
opname  = name of gate operation
nbits   = number of qubits it acts upon
nctrl   = number of control qubits
texsym  = latex symbol for the target qubit operation
qubit   - define a qubit with a certain name (all qubits must be defined)
name    = name of the qubit, eg q0 or j2 etc
initval = initial value (optional), eg 0
cbit    - define a cbit with a certain name (all cbits must be defined)
name    = name of the cbit, eg c0
initval = initial value (optional), eg 0
H       - single qubit operator ("hadamard")
X       - single qubit operator 
Y       - single qubit operator 
Z       - single qubit operator
S       - single qubit operator
T       - single qubit operator
nop     - single qubit operator, just a wire
space   - single qubit operator, just an empty space
dmeter  - measure qubit, showing "D" style meter instead of rectangular box
zero    - replaces qubit with |0> state
discard - discard qubit (put "|" vertical bar on qubit wire)
slash   - put slash on qubit wire
measure - measurement of qubit, gives classical bit (double-wire) output
cnot    - two-qubit CNOT
c-z     - two-qubit controlled-Z gate
c-x     - two-qubit controlled-X gate
swap    - two-qubit swap operation 
Utwo    - two-qubit operation U
ZZ      - two-qubit controlled-Z gate, symmetric notation; two filled circles
SS      - two-qubit gate, symmetric; open squares
toffoli - three-qubit Toffoli gate

Installation instructions

-----------------------------------------------------------------------------
REQUIREMENTS:

- latex2e with xypic (included in tetex)
- python version 2.3 or greater
- ghostscript (and epstopdf)
- netpbm (for creation of png files)

-----------------------------------------------------------------------------
LIST OF FILES:

README  - this file
meter.epsf     - picture of measurement meter
qasm2pdf - script to create PDF from QASM file
qasm2png - script to create PNG from QASM file
qasm2tex.py - main python program to convert QASM to latex file
samples - directory containing examples
xyqcirc.tex - latex macros necessary to compile the latex files

-----------------------------------------------------------------------------
INSTALLATION INSTRUCTIONS:

untar/unzip this distribution; it creates the directory qasm2circ with
all of the files.  Copy your qasm file into this directory, and run
qasm2pdf or qasm2png to create the desired output.  You may also run
"python qasm2tex.py foo.qasm" to generate just the tex file (it will
appear on stdout).

Quantum Architectures: continued.

2010-06-09T11:35:00.003+05:30

Example 1

[ test1.qasm |test1.png |test1.pdf |test1.eps |test1.tex ]

# 
# File:   test1.qasm
# Date:   22-Mar-04
# Author: I. Chuang 
#
# Sample qasm input file - EPR creation
#
qubit  q0
qubit  q1

h q0 # create EPR pair
cnot q0,q1

How Quantum Computers Work

2010-06-09T11:35:00.001+05:30

The massive amount of processing power generated by computer manufacturers has not yet been able to quench our thirst for speed and computing capacity. In 1947, American computer engineer Howard Aiken said that just six electronic digital computers would satisfy the computing needs of the United States. Others have made similar errant predictions about the amount of computing power that would support our growing technological needs. Of course, Aiken didn't count on the large amounts of data generated by scientific research, the proliferation of personal computers or the emergence of the Internet, which have only fueled our need for more, more and more computing power.
Will we ever have the amount of computing power we need or want? If, as Moore's Law states, the number of transistors on a microprocessor continues to double every 18 months, the year 2020 or 2030 will find the circuits on a microprocessor measured on an atomic scale. And the logical next step will be to create quantum computers, which will harness the power of atoms and molecules to perform memory and processing tasks. Quantum computers have the potential to perform certain calculations significantly faster than any silicon-based computer.

Scientists have already built basic quantum computers that can perform certain calculations; but a practical quantum computer is still years away. In this article, you'll learn what a quantum computer is and just what it'll be used for in the next era of computing.
You don't have to go back too far to find the origins of quantum computing. While computers have been around for the majority of the 20th century, quantum computing was first theorized less than 30 years ago, by a physicist at the Argonne National Laboratory. Paul Benioff is credited with first applying quantum theory to computers in 1981. Benioff theorized about creating a quantum Turing machine. Most digital computers, like the one you are using to read this article, are based on the Turing Theory.

Defining the Quantum Computer

2010-06-09T11:33:00.003+05:30

Image used under the GNU Free Documentation License 1.2
The Bloch sphere is a representation of a qubit, the fundamental building block of quantum computers.

The Turing machine, developed by Alan Turing in the 1930s, is a theoretical device that consists of tape of unlimited length that is divided into little squares. Each square can either hold a symbol (1 or 0) or be left blank. A read-write device reads these symbols and blanks, which gives the machine its instructions to perform a certain program. Does this sound familiar? Well, in a quantum Turing machine, the difference is that the tape exists in a quantum state, as does the read-write head. This means that the symbols on the tape can be either 0 or 1 or a superposition of 0 and 1; in other words the symbols are both 0 and 1 (and all points in between) at the same time. While a normal Turing machine can only perform one calculation at a time, a quantum Turing machine can perform many calculations at once.

Today's computers, like a Turing machine, work by manipulating bits that exist in one of two states: a 0 or a 1. Quantum computers aren't limited to two states; they encode information as quantum bits, or qubits, which can exist in superposition. Qubits represent atoms, ions, photons or electrons and their respective control devices that are working together to act as computer memory and a processor. Because a quantum computer can contain these multiple states simultaneously, it has the potential to be millions of times more powerful than today's most powerful supercomputers.

This superposition of qubits is what gives quantum computers their inherent parallelism. According to physicist David Deutsch, this parallelism allows a quantum computer to work on a million computations at once, while your desktop PC works on one. A 30-qubit quantum computer would equal the processing power of a conventional computer that could run at 10 teraflops (trillions of floating-point operations per second). Today's typical desktop computers run at speeds measured in gigaflops (billions of floating-point operations per second).

Quantum computers also utilize another aspect of quantum mechanics known as entanglement. One problem with the idea of quantum computers is that if you try to look at the subatomic particles, you could bump them, and thereby change their value. If you look at a qubit in superposition to determine its value, the qubit will assume the value of either 0 or 1, but not both (effectively turning your spiffy quantum computer into a mundane digital computer). To make a practical quantum computer, scientists have to devise ways of making measurements indirectly to preserve the system's integrity. Entanglement provides a potential answer. In quantum physics, if you apply an outside force to two atoms, it can cause them to become entangled, and the second atom can take on the properties of the first atom. So if left alone, an atom will spin in all directions. The instant it is disturbed it chooses one spin, or one value; and at the same time, the second entangled atom will choose an opposite spin, or value. This allows scientists to know the value of the qubits without actually looking at them.

Next, we'll look at some recent advancements in the field of quantum computing.

Qubit Control

Computer scientists control the microscopic particles that act as qubits in quantum computers by using control devices.

Ion traps use optical or magnetic fields (or a combination of both) to trap ions.
Optical traps use light waves to trap and control particles.
Quantum dots are made of semiconductor material and are used to contain and manipulate electrons.
Semiconductor impurities contain electrons by using "unwanted" atoms found in semiconductor material.
Superconducting circuits allow electrons to flow with almost no resistance at very low temperatures.

Its Quantum Computing

2010-06-09T11:33:00.001+05:30

"
Any qubit state is associated with a six-dimensional probability vector with components , where is the spin projection and defines a direction of spin projection measurement, . The ends of the vectors are on the sphere which is illustrated in the top-left corner. In general, is a probability distribution function of two discrete variables and , and determines a point on the five-simplex. If the directions are chosen with equal probability, then for all . In that case, a one-to-one correspondence can be established between all probability vectors and all points inside a cube , , which is illustrated in the top-right corner. In other words, any quantum state is associated with a probability vector of the form
,
where is a cube in of side .
The density operator is expressed through the probabilities by
,
where is the identity operator, are Pauli operators, and the vectors form a dual basis with respect to the vectors :
, , .
Non-negativity of the density operator is a necessary condition that leads to constraints on the probabilities . Using Sylvester's criterion, one obtains restrictions of the first and the second order (the blue and red surfaces inside the cube, respectively). In the probability space, the set of quantum states is an ellipsoid located between two planes. The set of qubit states is depicted in the top-right corner for any choice of directions .
The errors of experimentally measured probabilities result in the reconstruction procedure above being erroneous. The error bar is directly proportional to the condition number of the Gram matrix , which is the ratio of the absolute values of the maximum to the minimum eigenvalue. The behavior of the condition number is shown at the bottom.