IBM Wants Everyone to Try a Quantum Computer
nytimes.com
nytimes.com
A very similar quantum circuit simulator (in JS): http://www.davyw.com/quantum/?example=Grover%27s%20Algorithm
And now a shameless plug: If you want to learn quantum mechanics and quantum computing, you should check out my upcoming book on linear algebra: https://minireference.com/static/excerpts/noBSguide2LA_previ... available via https://gum.co/noBSLA
Another drag-and-drop quantum circuit simulator that runs in your browser is "Quirk" [0].
Quirk is faster than Davy's simulator thanks to webgl. It calculates varying operations on up to 16 qubits in real time as you drag gates around. It also lets you drop inline state displays into the circuit. Plus you can link to circuits, though the links can be a bit long so you may want to do so indirectly [1].
That being said, Quirk lacks the ability to compile circuits into a gate. Also it doesn't have a QFT gate (yet). I'm working on it. [2].
0: http://algorithmicassertions.com/quirk
1: https://t.co/qi12H3aVU1 (6-qubit grover circuit with displays, near the getting-laggy limit in terms of op-count)
One thing I never got around to that IBM did was measurement operators. They break my simple compilation strategy but would definitely make it more useful.
(Speaking of measurement. Quirk allows measurement... but it cheats. It refuses to let you hit measured qubits with operations that would superpose them again w.r.t. the computational basis. So the deferred measurement principle [1] applies, and there's no need to use density matrices and square the simulation cost.)
1: https://en.wikipedia.org/wiki/Deferred_Measurement_Principle
That's an interesting strategy. I'm going to have to dig deeper when I get a chance. You said you're also using WebGL for a performance?
PS: Those continuous gates are especially cool!
Basically I represent an n-qubit superposition as a 2^(n/2) x 2^(n/2) texture with each pixel being an amplitude (with red=real, blue=imaginary components). Then I use fragment shaders to operate on all the pixels in parallel when applying a gate.
For example, here's the GLSL in the main method of the "UniversalNot" gate's shader [1]:
vec2 xy = gl_FragCoord.xy - vec2(0.5, 0.5);
float state = xy.y * outputWidth + xy.x;
float hasBit = mod(floor(state / bit), 2.0);
float partnerState = state + bit * (1.0 - 2.0 * hasBit);
vec2 uv = uvFor(state);
vec2 partnerUv = uvFor(partnerState);
float control = texture2D(controlTexture, uv).x;
vec2 val = vec4(texture2D(inputTexture, uv)).xy;
vec2 partnerVal = vec4(texture2D(inputTexture, partnerUv)).xy;
vec2 outUncontrolled = vec2(partnerVal.x, -partnerVal.y) * (1.0 - 2.0*hasBit);
vec2 outVal = (1.0 - control) * val + control * outUncontrolled;
gl_FragColor = vec4(outVal.x, outVal.y, 0.0, 0.0);
1: https://github.com/Strilanc/Quirk/blob/master/src/circuit/Ga...
Suggestion: add some sort of menu for import/export and links to examples. I thought there was a limit to how long a URL hash can be, but it seems even very long ones will work.
[1] Of course, the local description doesn't really work for the Bell state (|00>+|11>): http://bit.ly/1rUFaos but still cool...
The other issue with the links is that the braces keep getting cut off by sites (as happened for your link, need to include that last } for it to work). But having the URL be the save mechanism is just so darn appealing to me.
I generally work around each qubit in an EPR pair appearing to be maximally mixed by conditioning the displays. Add a control to the other wire in the same column as the display, and you'll see the conditional state. Also there's the 2-qubit density matrix display.
Send me an email if the greyness bothers you—I'll be happy to send you a replacement copy from lulu, say when v6 comes out (no major changes; just more exercises because some people complained the onboarding was too hard for beginners).
You probably mean Quantum DevOps.
Quantum ops you are never sure.
Before you commit to reading 500 pages of intense math, you could probably get a lot of reviewing done with the short tutorial on LA[1].
[0] https://minireference.com/blog/linear-algebra-book-alpha-rel... [1] http://minireference.com/static/tutorials/linear_algebra_in_...
From the press release: "The quantum processor is composed of five superconducting qubits and is housed at the IBM T.J. Watson Research Center in New York. The five-qubit processor represents the latest advancement in IBM’s quantum architecture that can scale to larger quantum systems. It is the leading approach towards building a universal quantum computer." (http://www-03.ibm.com/press/us/en/pressrelease/49661.wss)
From the demo video: looks like you can use hadamard and CNOT gates as well as measurements. Somehow it sounds like you can also apply oracles (not sure how you specify what they are when it gets run). (https://youtu.be/pYD6bvKLI_c)
They use a trivial oracle circuit as an example. But Grover's algorithm works for any oracle circuit, so in principle it could be a circuit that verifies if its input is a proof of the Riemann hypothesis.
https://quantumexperience.mybluemix.net/ is the actual site
And of course you want a lot of conventional machine around the quantum processor (even a hypothetical much bigger one), as you would around any special-purpose hardware (you have it even around a GPU).
The particular configuration that the software defines for the controlling machinery (and how it sets up the qubit entanglement) is meant to implement the chosen quantum computing algorithms and to encode the chosen inputs.
For example, for a given instance of Shor's algorithm and for one given public key, you'd first calculate how to encode this configuration into the qubits, then load it up, to then run it over and over and interpret all of the outputs to look for a useful answer.
I've got no idea how the qubit programming is practically implemented.
There used to be a separate FPU processor for math / floating point operations.
Then there was a separate GPU processor for graphics / parallel processing.
Now, this.
Brain: The same thing we do every night, Pinky - try to take over the world!
______
Currently, I'm not aware of anything that's not able to be done with QC qubits that not able to be done with classical binary computation.
If you wanted, you can download quantum computer simulator, write some QC'ish code, run the code, and you'll never write any code that won't resolve with crashing or taking forever, though it'd be faster on the 5 qubits though.
2. Grover's algorithm
3. Quantum simulation
If you're not doing those three things, throw it in the trash, more or less.
So while classical miners are brute forcing through a 2^70 search space, the quantum miner can find a solution in roughly sqrt(2^70) = 2^35 steps.
Other proof-of-work systems can be more quantum resistant, e.g. looking for a fixed-length cycle in a huge random graph, for which no efficient quantum algorithm is known.
And you must reset part of the problem (the previous block hash, at minimum) when new blocks are released, adding some latency (you need to recompute the qubit configuration before resuming).
But perhaps a SIDH based proof-of-work algorithm could be implemented to further resist QC speedups. Don't know exactly how that would work. Does Grover's still apply?
There are about 2^256/2^160=2^96 possible full public keys mapping to the known key hash, so you could run Grover's algorithm to recover one in about sqrt(2^96)=2^48 steps, but given the slow cycle time of quantum computers, that's still going to be infeasible for a long time.
This is why address re-use is not recommended...
Plus, developers probably won't need to interact directly with this stuff when the day comes. I'm sure there will be some set of common quantum tasks abstracted away behind the scenes.
Edit: Okay I'm ridiculous, it has a real nice graphical interface.
I sort of agree with Scott Aaronson on why he thinks consciousness is finite[0].
The problem, IMO, that Penrose has is that his theories border closely on mysticism - there's some quantum "magical" process whereby consciousness arises. Both pictures are incomplete, but Aaronson's is the most plausible.
Classical (Newtonian) mechanics seem sufficient enough to explain how neurons work.
Thanks for the link. I do have trouble with the above statement, and what follows it, as I would think that the number of states of the human body (or even just the brain & nervous system) would be infinite (that is, in the sense of the infinite cardinality of real numbers) and not countably infinite (as in the set of whole numbers). This would follow from the entire system operating as a biochemical process, and neuronal stimulus being an analog signal between a finite number of neuron cells. Thoughts?
I suggest the number of possible states is infinite since the signals between neurons are analog (though I acknowledge this one-word categorization is a major simplification of the actual process of neuronal stimulation).
Not really
Why does the guy who discovered the time of quantum decoherence (Claude Cohen Tanoudji) says quantum computing might be a scam?
Okay, people may think he is a fraud, but he was able to trap very few photons in a cavity and measure that quantum decoherence disappear with order of magintude of 10^-13seconds.
Ho! And maybe quantum computing is fast, but how fast is it for an operator to translate a NEW problem (different from factorisation) into a quantum code?
Well, least but not last, reading the libquant (freely inspired from quantum mechanics to compute risks) I can't help that notice that most so called smart boys with degrees in maths are totally clueless about quantum mechanic, because quantum mechanics is based on probability, and most human don't grasp it. So how can I trust less than able non -as smart and honest person- as traders to grasp QM?