No, you can't do that. There's a difference between "iff" ("if and only if") and "if"; you don't just have to prove
"inner product preserving" => UU*=U*U=I
What you need is
"inner product preserving" <=> UU*=U*U=I
If you do that, it doesn't matter what you use as definition and what you prove, the work is exactly the same. So you might as well use the same definition as everyone else.
It's idiotic to prove that. The right way to do things is define them as inner product preserving and then it's immediate that they are length preserving.
... what?
That's like saying "It's idiotic to prove the Pythagoras theorem. The right way to do things is to define 'right-angled triangle' as a triangle that has sides obeying a^2=b^2+c^2". Sure, you could do that, but then you have to prove that a triangle is 'right-angled' iff it has one of its angles equal to 90 degrees.
Similarly, if you define "unitary" as "inner product preserving", then you have to prove that U is unitary iff UU*=U*U.
I'll try to answer this, even though it's a little late, and I don't know if you'll ever read this. Be warned that I'm not a physicist -- but I've studied quite a bit of quantum computing, and I asked the same kinds of questions you're asking.
The thing is, a superposition of 2 states (or actually any finite number of states) is not really that interesting or weird, unless you're also talking about entanglement. Unfortunately, quantum computers really need entanglement to work. [Note that when you're talking about position, momentum, energy or time (and many other things), the number of states is infinite, so things become even weirder.]
The way to measure an electron spin (I'll stick to this example) is to apply around the electron a strong magnetic field in the "up" direction (whatever you decide that to be) and wait a little. The amount of time you have to wait depends on the strength of the field you applied -- the stronger the field, the less time you have to wait. If the spin of the electron is already "up", nothing will happen. If the spin of the electron is "down", the electron will emit a photon and its spin will change to "up". This means that if you detect a photon after you applied the magnetic field, you "measured" the spin to be "down", and if there was no photon, you "measured" it to be "up". After the measurement, the original spin is ruined: it's always up, because the magnetic field forces it to become that way.
A superposition of "50%up and 50%down" with no entanglement with anything else can be encoded as an electron with spin pointing to the "left" (or any direction perpendicular to the up/down axis, really). To read it, you would apply the same strong magnetic field pointing up and wait for the photon. You get the same thing as the non-superposition states: a photon means you measured "down", no photon means "up". You can only know the probability (in this case "up" and "down" are both 50%) if you repeat the whole thing from the start (i.e., make the spin point left, and then apply the field and wait for the photon) many times. You can change the amounts in the superposition by varying the angle between the spin and the "up" direction. That is: if the spin is almost, but not quite, in the "up" direction, you would get, say, "95%up and 5%down", and so on.
The problem is: if someone hands you an electron and doesn't tell you which direction its spin is pointing, there's really nothing better you can do to find the direction of the spin than what I described: the best you can get is an "up"/"down" answer relative to a direction of your choosing. Now, the important thing is: when you're talking about an electron that is not entangled, the spin is always pointing in a determinate direction, even though you might not know what it is. That means that there's always a measurement you could make (if you knew which direction to measure) that would give a deterministic answer. That is, if you apply the magnetic field in the direction the electron spin is already pointing, you will always read "up", i.e., no photon.
Things start to become weird when you allow the spins of two (or more) electrons to interact (and become entangled). If you put two electrons close to each other and far from anything else (and free from any magnetic field), after a while their spins will become "maximally entangled", which is a weird state in which the nice property I described above (having a determinate spin direction) is no longer true. That is, there's no direction that you could make a measurement that would give a deterministic answer. For any direction, you'd have 50% of probability of reading up and 50% of down. That remains true even if you separate the electrons, until you (or something else) measures the spin and forces it to be determinate again. You have to note that to measure a spin, any magnetic field is sufficient (although a very weak field would take a relatively long time to measure it), so it's very hard to maintain this entangled state. What i
Yes, except for the final step, which is trivial (and also fast) to simulate but a little harder to explain: you have to "make a measurement", which can be simulated simply as choosing randomly one of the 2^n components of the vector, according to probabilities that depend on the values of each component. The relative probability of each component can be calculated as the square of the absolute value the component (remember, these are complex numbers).
So, quantum algorithms have to be designed so that in the end of the calculation (i.e., before the measurement), the vector has all components -- except one (the right answer) -- very close to zero. This means that when you make the measurement, you have a very high probability of getting the right answer. This requirement is what makes it so hard to "program" a quantum computer: you have to find a way to make all wrong answers come up with extremely low probabilities. You can then increase you confidence in the result even more by running the algorithm many times to avoid being fooled by unlucky outcomes. For example, if the probability of getting the wrong result in one run is 1% (=0.01), then if you run the program 5 times the probability of getting the wrong result becomes 0.01^5=0.0000000001.
This, of course, is all conceptual; actual simulations do all kinds of optimizations depending on the kind of algorithm being run (i.e., if you know some properties of the matrices, you usually don't have to do the full multiplications, etc.).
(I'm not a physicist, but I have studied some quantum computing.)
Even though I suspect it's wise to listen to a physicist's intuition on these matters, I think your intuition might have been clouded by the hype surrounding quantum computers. The truth is that there's really no free lunch. Nobody (outside the media) claims that quantum computers instantly solve all kinds of problems.
Think of it this way: some things in quantum mechanics are very hard to simulate using classical computers (it's much harder than simulating classical mechanics). So, it seems reasonable that, if you have some way of using quantum mechanics to do the calculations, you can do better than classical computers. I believe that Feynman was one of the first people to suggest that. He was actually talking about using a quantum system to calculate the behavior of another quantum system, but a quantum computer is essentially a slight generalization: using a quantum system to calculate something else, not necessarily the behavior of another quantum system.
The problem becomes: what kind of calculations can be improved by using a quantum system? There are strong indications that not every kind of problem gains too much from quantum computers: for example, most complexity theorists believe that quantum computers cannot solve NP-hard problems. One of the only kind of problems we have found so far that gain a lot from it is factoring integers.
In other words, a four-qubit computer may be nearly useless except for very specific problems; but if it was part of your desktop computer, it would give it a large boost in all sorts of power.
Not really; a four-qubit quantum computer can be simulated very fast in today's computers. It would be completely useless for any practical purpose (unless quantum computer fabrication technology improvements become ridiculously better than improvements on classical computer fabrication technology for an extended period of time).
To simulate the evolution of an n-qubit quantum computer all you have to do is (essentially) multiply a vector of size 2^n by a series of 2^n-by-2^n matrices whose entries are complex numbers; each matrix multiplication represents one step of the algorithm you're running. There are, of course, many optimizations that can be done depending on the type of algorithm you're running. (Here is a nice list of quantum simulators.)
Because the size of the vectors and matrices grows exponentially (2^n) with the number of qubits, simulating a quantum computer with a classical computer becomes impractical even for a moderate size. For very a very small number of qubits, though, it's completely reasonable.
That said, the rest of what you said seems right. Even though it would be possible to run classical algorithms in a quantum computer (i.e., quantum computers are Turing-complete), it would probably be an enormous waste of resources to use quantum computers that way. Unless, of course, quantum computer fabrication technology improvements become ridiculously better, etc.
The research about predicting revolutions is awful. I don't understand how some people in social sciences still get to publish these results without even remotely trying to avoid confirmation bias.
If you read the research linked from the BBC story, you can see that they do indeed have some impressive-looking graphics that show how the media reporting changed prior to some revolutions. That's interesting, but it's completely and utterly useless without also taking random samples from other places and times and checking if the same changes don't happen when there's no revolution. If they do, the whole "finding" is almost useless: it's only slightly better than always predicting revolutions whenever you want to make a prediction.
The Windows XP machine I'm using has the Tunisian government certificate authority installed (it's named "Agence Nationale de Certification Electronique").
An easy way to check if you have it is to simply go to the Tunisian Certification Agency site (with https). If your browser shows a warning saying that the certificate authority can't be confirmed (or something like that), you don't have the Tunisian Govt CA. If it doesn't show any warnings, it probably means you do have the CA -- to check it, ask your browser about the certification information of the site (by clicking in the "lock" icon). Somewhere in the interface (I'm not sure how much it changed in Windows 7) you should see the "certification path" -- the root should be a certificate named "Agence Nationale de Certification Electronique", and in its details you can see the issuer country is TN (Tunisia).
<rant> The situation of https authentication is increasingly a joke. Look at the number of CAs you have installed in Windows. Any of these organizations could sign any site, which means that simply seeing a lock icon in your browser's URL bar means almost nothing; for it to mean anything, you should check who signed the site's certificate. </rant>
Well, given how much he already suffered for his crimes (e.g., eight months in solitary confinement) and how much scumbaggery there was against him during his prosecution, I don't think he feels much sympathy for his victims. For example, from his previous answers to/.:
Federal prosecutors simply added up all the R&D costs associated with the source code I had accessed, and used that number (approx $300 million) as the loss, even though it was never alleged that I intended to use or disclosed any source code. Interestingly enough, none of my victims had reported any losses attributable to my activities to their shareholders, as required by securities laws.
Still, if the money from this book had any chance to repair any real damage he did in any meaningful way, I'd agree that it would be descent to publish earlier. I don't think would, though, and I think it's pretty clear that neither does he.
Negative mass/energy is NOT antimatter, but rather "exotic" matter.
Sure. But I think the AC is referring to is how Dirac "discovered" anti-matter using nothing but math.
Basically, you can use a theorem about the Fourier transform to show that in certain circumstances, you either need to allow negative energy or you need to allow virtual particles to travel faster than light.
Assuming negative energies are nonsense, you're stuck with virtual particles (in this case, electrons) that travel faster than light. According to special relativity (which Dirac had to make compatible with quantum mechanics), for some observers, it appears that the electrons are travelling backwards in time. Then, using a symmetry property (parity times time reversal equals charge conjugation), you end up concluding that there must exist particles that appear to be exactly the same as electrons, but have positive charge -- and, as you wrote, antimatter is just that.
[Disclaimer: I'm not a physicist; I got this from Feynman's lecture "The reason for antiparticles", available in this book]
The amazing thing is that a few years after Dirac published this theory purely based on math, someone was able to do experiments to actually observe the antimatter that was predicted. Like the AC, I think that this shows that math is an integral part of doing physics, and not just some way to formalize what physicists know.
Great question. There are already some answers, but I'll try to give my own try:
The bra-ket things are just a convenient notation for working with vectors and dot product in old boring linear algebra. Standard courses of linear algebra don't usually teach the bra-ket notation, but if you know linear algebra, it's very easy to get used to it. When I first tried to, I still sometimes re-wrote things in the standard notation, especially when things started to get a little confusing, but after a while, you begin to realize that things get more compact and easy to visualize in the bra-ket notation (when you're restricted to just what you need for quantum mechanics).
As for quantum mechanics: if you really want to learn full-blown QM, there's no escape from learning a lot of classical mechanics (including electromagnetism, etc), which takers a long time and maybe is not really what you're interested. But if just want to have a good understanding of exactly how QM is strange, and even learn to do some calculations with it, you might like these series of lectures in youtube given by Leonard Susskind:
The first two lectures are a little slow but, but he starts from the absolute beginning, and tells you exactly what is meant by the bra-kets, and goes from there to teaching about interference and eventually entanglement, which are the two insanely counter-intuitive and strange things about QM.
After that (or instead of that, if you know calculus), you might want to watch this one:
For this one you need a little bit of calculus, but you get to play with the Schrodinger equation and see where exactly the Heisenberg's Uncertainty Principle comes from (at least math of it).
The problem is not that adding support to a new board in Linux is too hard, in fact, it's almost the opposite. There are already tens of slightly incompatible boards to support, and every time a company makes a new one, they don't even try to stick to any standard (not that there even *exists* a real standard), since it's very easy to just add new code to Linux. See this LKML thread for Linus's description of the problem from some time ago.
Using a microkernel doesn't help at all; you still have to code for all of the slight incompatibilities, regardless of whatever differences in logical organization.
What does your favorite language do in this case? Does its memory model have a local stack concept at all? I guess I'm not sure how any other language with a local stack model would implement this without promoting the variable to long-lived storage.
That depends heavily on the language and possibly on how you choose to implement it.
Lua 5, for example, "lifts" the variable from the stack to the heap when a closure referencing it survives the block where it was created (it calls the variables that are closed over "upvalues"). It's not problematic as C++ because you can't get the address of a variable (so it doesn't matter when the address changes). Scheme and Lisp have many different implementations that vary wildly: from the "lifting" that Lua does to letting the variable live on the stack frame where it was created, and garbage collect stack frames the same way heap is garbage collected (see here). I'm not familiar with other language and/or implementation strategies, but I'm sure there are many more ways to do it, and many variations over what I just mentioned.
Is this really a case of C++ not providing the equivalent to some other language or is it instead a case of extra C++ functionality that doesn't map onto another language's memory model well. In C++11 one can certainly create closures over objects that are global, on the heap, etc. and pass them around at will.
Well, even ignoring the fact that you can't really close over variables that are on the stack (because you can "close over" stuff on the heap by making the lambda reference the pointer by value -- I assume that this is what you mean by "create closures over objects that are on the heap"), as far as I can tell closures lose a lot of usefulness when you don't have garbage collection. Just as a quick example (I'm sure this isn't the best example, but it's all I can think of right now), closures are great for setting up ad-hock event handling, with some objects shared by a few event handlers belonging to a window. That would be very awkward in C++, because you'd have to make sure someone is responsible for deleting the objects when the event handlers disappear (one would probably end up having to subclass the window and add the objects to its list of members, and then you'd have to make sure the right original window's methods are virtual, etc.).
Um...you can. Thus the whole bit about capture lists. std::function is your friend.
No, you can't -- not when it would matter for C++ lambdas to be equivalent to other language's closures. The "while bit about capture lists" is there, in part, to specify exactly when you can.
If one or more names in the effective capture set are preceded by &, the effect of invoking a closure object or a copy after the innermost block scope of the context
of the lambda expression has been exited is undefined.
So, when the lambda actually "closes over" a variable (not just capturing its value), you can't use it outside the block where it was defined. That's unsurprising, since it would mean keeping the stack alive or "lifting" the variable from the stack into the heap, which would open a whole new can of worms.
When people say that a language has closures, they mean that a closure is a first class object: in particular, you should be able to return it from the function/method where it was created.
You could argue that being able to return a lambda would be very un-C++-like, and I tend to agree -- it feels like returning a pointer to a stack variable (in fact, it would be something close to that, if the lambda captures a stack variable). You could argue that returning a lambda would be mostly useless in C++ (I'd disagree, but whatever). You could even argue about the semantics of the name "closure", and whether it should imply being a first class object.
But don't fool yourself into thinking that C++'s lambda is equivalent to what's called a "closure" in other languages; it's not.
The only way we could have true randomness is if there are some sort of measurable phenomena that cannot be predicted. Quantum mechanics dances around this question, and even if there is a state change that is genuinely random, it would be difficult bordering on heroic to measure it in a practical way so as to create a random number generator.
Actually, there are many commercial devices that use quantum effects to generate sequences of numbers that are unpredictable even in theory. Or, if you're careful about it, you can even use a simple Geiger counter to generate truly random data.
Re:really scraping the bottom of the barrel
on
Happy Tau Day
·
· Score: 1
Whoa, thank you very much! At first look, it seems be exactly what I need! Now it seems I'll have to get used to Maxima's way of doing things.:)
And indeed, Maxima is even included with Sage, although I don't know what exactly Sage uses it for...
Re:really scraping the bottom of the barrel
on
Happy Tau Day
·
· Score: 1
The general formula for a circle does not favor Pi or Tau but the general formula for finding an area for simple shapes does favor Tao.
I disagree. I don't think it "favors" tau or pi, I think the choice is arbitrary. Before you start thinking I'm an idiot, or simply trying to be difficult just to maintain the status quo, please read my whole explanation.
The example of calculating the area of the circle in The Tau Manifesto does an integral with the radius going from 0 to r. When dealing with a circle, if you think in terms of the radius (as opposed to the diameter), tau is more natural: this is unsurprising, since The Tau Manifesto itself defines it as tau=C/r. Obviously, when dealing of a circle, you think about the diameter (and not the radius), then pi is more natural: pi=C/d.
When you compare the integral (using the radius) with the other simple integrals from physics, you may get a sense of discovering an underlying pattern (in Table 3 (page 16) everything has the exact same formula structure) and all of a sudden everything seems to fit in place. It begins to look like it's obvious that you should choose to work with the radius, and not the diameter. Most of the feeling that tau is "simply better" or "more natural" seems to come from this realization (and other similar ones in the other examples in the Manifesto).
I claim that this is misleading, and it simply isn't true that "the general formula for finding an area for simple shapes does favor Tao". It just happens that, coincidentally, there's a simple way to calculate the area of the circle that integrates over the radius. But if you wanted to calculate the area of a square, or of a triangle, or, even better, some arbitrary shape, the simplest thing to do would NOT be to pick a point inside the shape and integrate over some "rings" (or whatever shape) while moving away from this point to the edge of the shape. Moreover, it is a coincidence that this way to calculate the area of the circle (integrating using the radius, which favours tau) works as beautifully as it does -- it doesn't look as good in any larger dimension (volume, etc.).
But that's just one example. There are many others, usually just silly or misleading in some other way. As for the claim that everywhere you see pi in a formula it's always multiplied by 2, that's just silly.
Still, I already said I agree that tau is better in some places. For example, e^(i*tau) looks more natural than e^(2*i*pi), for the exact same reason that sin(x)=sin(x+2*pi): in the "natural" definition of the trigonometrical functions, 2*pi is "one full circle back to the same point". But that seems to be the only real argument. It's been obvious for a very long time and it doesn't seem reason enough to justify a massive change in the way we write these things. Gratuitous incompatibility is bad!
Re:really scraping the bottom of the barrel
on
Happy Tau Day
·
· Score: 1
Yes, I never disagreed that sometimes it makes more sense to use tau. Still, I play a lot with complex arithmetic (by hand! [1]) when learning quantum computation. I've never had a single instance where absorbing the "2" into a constant (tau) would make things dramatically simpler.
The main point, though, is that people seem to make it a bigger deal about it than what it is. It's just a constant. Sometimes it makes more sense (in a "pure" sort of way) to use tau -- especially in really simple examples, it seems. Sometimes, it makes more sense to use pi. Most of the time, though, it doesn't really matter, since there are other constants involved either way. It seems that the benefits of using a single standard (pi is already established) seems to vastly outweigh the trouble of getting used to another constant.
[1] BTW, if anyone knows where I can find some easy-to-use free software that deals *symbolically* with complex matrices -- in particular, multiplying, inverting and calculating eigenvalues and eigenvectors, I'd LOVE hear about it. I mostly use Sage (it's what I ended up using after searching a bit a few years ago), but I end up doing a lot by hand because it seems to refuse to deal with complex numbers in any sensible way -- it doesn't like to keep constants like pi or sqrt(2), and replaces them with inexact floating point values. Mathematica seems to do the right thing -- is there some free software that does the same?
Re:really scraping the bottom of the barrel
on
Happy Tau Day
·
· Score: 1
There's no question that "The Tau Manifesto" makes valid points that tau makes more sense than pi in some settings.
Still, I'm a little astounded by all the people that treat this as some profound insight. "The Tau Manifesto" itself is written in a tongue-in-cheek way, and it fits: it's not meant to be taken too seriously. At least, I never thought it was. The examples are hand-picked to make tau look good, and even among them, some are not fully developed: if they were, the arguments would fall apart.
Take the example of the area of the circle. If you generalize for n dimensions, all the talk about comparing it to formulas in physics (uniform acceleration, potential energy, etc.) to justify the 1/2 factor (which would be an argument for using pi) disappears: the general formula doesn't favor either pi or tau, it has ugly constants with both of them (it could even be argued that it looks better with pi).
And what's the point of saying "Tau fixes that in all cases I am aware of (If you know any it does not please post them)"? Things like this might go well in discussions about religion, not math.
As far as I understand, you can download and change OpenJDK (it's GPL v2), but if you want to distribute your version without fear of being sued for patent infringement, you must make sure your own version (i.e., OpenJDK plus you changes) passes the TCK -- that is, you must prove to Oracle that it's really "Java", and not some other language that's slightly incompatible with it.
TCK, of course, is not open. When you ask Oracle for the TCK, they want to know what you will do with it (see here), and they are free to deny it or put any restrictions they want on it.
Not without explicit permission from the autors; Snes9x license explicitly forbids it:
Snes9x is freeware for PERSONAL USE only. Commercial users should
seek permission of the copyright holders first. Commercial use includes,
but is not limited to, charging money for Snes9x or software derived from
Snes9x, including Snes9x or derivatives in commercial game bundles, and/or
using Snes9x as a promotion for your commercial product. [my emphasis]
Slashdot Mirror
Then the property you mention follows easily.
No, you can't do that. There's a difference between "iff" ("if and only if") and "if"; you don't just have to prove
"inner product preserving" => UU*=U*U=I
What you need is
"inner product preserving" <=> UU*=U*U=I
If you do that, it doesn't matter what you use as definition and what you prove, the work is exactly the same. So you might as well use the same definition as everyone else.
Between the Easter Bunny, Santa Clause and now the Speed of Light, I've learned not to let hard boarders block free thinking.
Why not throw away conservation of energy, also? Don't let reason block your creativity, quantum computing could heat your coffee for free!
It's idiotic to prove that. The right way to do things is define them as inner product preserving and then it's immediate that they are length preserving.
... what?
That's like saying "It's idiotic to prove the Pythagoras theorem. The right way to do things is to define 'right-angled triangle' as a triangle that has sides obeying a^2=b^2+c^2". Sure, you could do that, but then you have to prove that a triangle is 'right-angled' iff it has one of its angles equal to 90 degrees.
Similarly, if you define "unitary" as "inner product preserving", then you have to prove that U is unitary iff UU*=U*U.
I'll try to answer this, even though it's a little late, and I don't know if you'll ever read this. Be warned that I'm not a physicist -- but I've studied quite a bit of quantum computing, and I asked the same kinds of questions you're asking.
The thing is, a superposition of 2 states (or actually any finite number of states) is not really that interesting or weird, unless you're also talking about entanglement. Unfortunately, quantum computers really need entanglement to work. [Note that when you're talking about position, momentum, energy or time (and many other things), the number of states is infinite, so things become even weirder.]
The way to measure an electron spin (I'll stick to this example) is to apply around the electron a strong magnetic field in the "up" direction (whatever you decide that to be) and wait a little. The amount of time you have to wait depends on the strength of the field you applied -- the stronger the field, the less time you have to wait. If the spin of the electron is already "up", nothing will happen. If the spin of the electron is "down", the electron will emit a photon and its spin will change to "up". This means that if you detect a photon after you applied the magnetic field, you "measured" the spin to be "down", and if there was no photon, you "measured" it to be "up". After the measurement, the original spin is ruined: it's always up, because the magnetic field forces it to become that way.
A superposition of "50%up and 50%down" with no entanglement with anything else can be encoded as an electron with spin pointing to the "left" (or any direction perpendicular to the up/down axis, really). To read it, you would apply the same strong magnetic field pointing up and wait for the photon. You get the same thing as the non-superposition states: a photon means you measured "down", no photon means "up". You can only know the probability (in this case "up" and "down" are both 50%) if you repeat the whole thing from the start (i.e., make the spin point left, and then apply the field and wait for the photon) many times. You can change the amounts in the superposition by varying the angle between the spin and the "up" direction. That is: if the spin is almost, but not quite, in the "up" direction, you would get, say, "95%up and 5%down", and so on.
The problem is: if someone hands you an electron and doesn't tell you which direction its spin is pointing, there's really nothing better you can do to find the direction of the spin than what I described: the best you can get is an "up"/"down" answer relative to a direction of your choosing. Now, the important thing is: when you're talking about an electron that is not entangled, the spin is always pointing in a determinate direction, even though you might not know what it is. That means that there's always a measurement you could make (if you knew which direction to measure) that would give a deterministic answer. That is, if you apply the magnetic field in the direction the electron spin is already pointing, you will always read "up", i.e., no photon.
Things start to become weird when you allow the spins of two (or more) electrons to interact (and become entangled). If you put two electrons close to each other and far from anything else (and free from any magnetic field), after a while their spins will become "maximally entangled", which is a weird state in which the nice property I described above (having a determinate spin direction) is no longer true. That is, there's no direction that you could make a measurement that would give a deterministic answer. For any direction, you'd have 50% of probability of reading up and 50% of down. That remains true even if you separate the electrons, until you (or something else) measures the spin and forces it to be determinate again. You have to note that to measure a spin, any magnetic field is sufficient (although a very weak field would take a relatively long time to measure it), so it's very hard to maintain this entangled state. What i
Just so you know what's going on here: http://slashdot.org/story/01/10/23/1816257/apple-releases-ipod
Yes, except for the final step, which is trivial (and also fast) to simulate but a little harder to explain: you have to "make a measurement", which can be simulated simply as choosing randomly one of the 2^n components of the vector, according to probabilities that depend on the values of each component. The relative probability of each component can be calculated as the square of the absolute value the component (remember, these are complex numbers).
So, quantum algorithms have to be designed so that in the end of the calculation (i.e., before the measurement), the vector has all components -- except one (the right answer) -- very close to zero. This means that when you make the measurement, you have a very high probability of getting the right answer. This requirement is what makes it so hard to "program" a quantum computer: you have to find a way to make all wrong answers come up with extremely low probabilities. You can then increase you confidence in the result even more by running the algorithm many times to avoid being fooled by unlucky outcomes. For example, if the probability of getting the wrong result in one run is 1% (=0.01), then if you run the program 5 times the probability of getting the wrong result becomes 0.01^5=0.0000000001.
This, of course, is all conceptual; actual simulations do all kinds of optimizations depending on the kind of algorithm being run (i.e., if you know some properties of the matrices, you usually don't have to do the full multiplications, etc.).
(I'm not a physicist, but I have studied some quantum computing.)
Even though I suspect it's wise to listen to a physicist's intuition on these matters, I think your intuition might have been clouded by the hype surrounding quantum computers. The truth is that there's really no free lunch. Nobody (outside the media) claims that quantum computers instantly solve all kinds of problems.
Think of it this way: some things in quantum mechanics are very hard to simulate using classical computers (it's much harder than simulating classical mechanics). So, it seems reasonable that, if you have some way of using quantum mechanics to do the calculations, you can do better than classical computers. I believe that Feynman was one of the first people to suggest that. He was actually talking about using a quantum system to calculate the behavior of another quantum system, but a quantum computer is essentially a slight generalization: using a quantum system to calculate something else, not necessarily the behavior of another quantum system.
The problem becomes: what kind of calculations can be improved by using a quantum system? There are strong indications that not every kind of problem gains too much from quantum computers: for example, most complexity theorists believe that quantum computers cannot solve NP-hard problems. One of the only kind of problems we have found so far that gain a lot from it is factoring integers.
In other words, a four-qubit computer may be nearly useless except for very specific problems; but if it was part of your desktop computer, it would give it a large boost in all sorts of power.
Not really; a four-qubit quantum computer can be simulated very fast in today's computers. It would be completely useless for any practical purpose (unless quantum computer fabrication technology improvements become ridiculously better than improvements on classical computer fabrication technology for an extended period of time).
To simulate the evolution of an n-qubit quantum computer all you have to do is (essentially) multiply a vector of size 2^n by a series of 2^n-by-2^n matrices whose entries are complex numbers; each matrix multiplication represents one step of the algorithm you're running. There are, of course, many optimizations that can be done depending on the type of algorithm you're running. (Here is a nice list of quantum simulators.)
Because the size of the vectors and matrices grows exponentially (2^n) with the number of qubits, simulating a quantum computer with a classical computer becomes impractical even for a moderate size. For very a very small number of qubits, though, it's completely reasonable.
That said, the rest of what you said seems right. Even though it would be possible to run classical algorithms in a quantum computer (i.e., quantum computers are Turing-complete), it would probably be an enormous waste of resources to use quantum computers that way. Unless, of course, quantum computer fabrication technology improvements become ridiculously better, etc.
The research about predicting revolutions is awful. I don't understand how some people in social sciences still get to publish these results without even remotely trying to avoid confirmation bias.
If you read the research linked from the BBC story, you can see that they do indeed have some impressive-looking graphics that show how the media reporting changed prior to some revolutions. That's interesting, but it's completely and utterly useless without also taking random samples from other places and times and checking if the same changes don't happen when there's no revolution. If they do, the whole "finding" is almost useless: it's only slightly better than always predicting revolutions whenever you want to make a prediction.
The Windows XP machine I'm using has the Tunisian government certificate authority installed (it's named "Agence Nationale de Certification Electronique").
An easy way to check if you have it is to simply go to the Tunisian Certification Agency site (with https). If your browser shows a warning saying that the certificate authority can't be confirmed (or something like that), you don't have the Tunisian Govt CA. If it doesn't show any warnings, it probably means you do have the CA -- to check it, ask your browser about the certification information of the site (by clicking in the "lock" icon). Somewhere in the interface (I'm not sure how much it changed in Windows 7) you should see the "certification path" -- the root should be a certificate named "Agence Nationale de Certification Electronique", and in its details you can see the issuer country is TN (Tunisia).
<rant>
The situation of https authentication is increasingly a joke. Look at the number of CAs you have installed in Windows. Any of these organizations could sign any site, which means that simply seeing a lock icon in your browser's URL bar means almost nothing; for it to mean anything, you should check who signed the site's certificate.
</rant>
Well, given how much he already suffered for his crimes (e.g., eight months in solitary confinement) and how much scumbaggery there was against him during his prosecution, I don't think he feels much sympathy for his victims. For example, from his previous answers to /.:
Federal prosecutors simply added up all the R&D costs associated with the source code I had accessed, and used that number (approx $300 million) as the loss, even though it was never alleged that I intended to use or disclosed any source code. Interestingly enough, none of my victims had reported any losses attributable to my activities to their shareholders, as required by securities laws.
Still, if the money from this book had any chance to repair any real damage he did in any meaningful way, I'd agree that it would be descent to publish earlier. I don't think would, though, and I think it's pretty clear that neither does he.
Negative mass/energy is NOT antimatter, but rather "exotic" matter.
Sure. But I think the AC is referring to is how Dirac "discovered" anti-matter using nothing but math.
Basically, you can use a theorem about the Fourier transform to show that in certain circumstances, you either need to allow negative energy or you need to allow virtual particles to travel faster than light.
Assuming negative energies are nonsense, you're stuck with virtual particles (in this case, electrons) that travel faster than light. According to special relativity (which Dirac had to make compatible with quantum mechanics), for some observers, it appears that the electrons are travelling backwards in time. Then, using a symmetry property (parity times time reversal equals charge conjugation), you end up concluding that there must exist particles that appear to be exactly the same as electrons, but have positive charge -- and, as you wrote, antimatter is just that.
[Disclaimer: I'm not a physicist; I got this from Feynman's lecture "The reason for antiparticles", available in this book]
The amazing thing is that a few years after Dirac published this theory purely based on math, someone was able to do experiments to actually observe the antimatter that was predicted. Like the AC, I think that this shows that math is an integral part of doing physics, and not just some way to formalize what physicists know.
Great question. There are already some answers, but I'll try to give my own try:
The bra-ket things are just a convenient notation for working with vectors and dot product in old boring linear algebra. Standard courses of linear algebra don't usually teach the bra-ket notation, but if you know linear algebra, it's very easy to get used to it. When I first tried to, I still sometimes re-wrote things in the standard notation, especially when things started to get a little confusing, but after a while, you begin to realize that things get more compact and easy to visualize in the bra-ket notation (when you're restricted to just what you need for quantum mechanics).
As for quantum mechanics: if you really want to learn full-blown QM, there's no escape from learning a lot of classical mechanics (including electromagnetism, etc), which takers a long time and maybe is not really what you're interested. But if just want to have a good understanding of exactly how QM is strange, and even learn to do some calculations with it, you might like these series of lectures in youtube given by Leonard Susskind:
Quantum Entanglements: Part 1 (Fall 2006)
The first two lectures are a little slow but, but he starts from the absolute beginning, and tells you exactly what is meant by the bra-kets, and goes from there to teaching about interference and eventually entanglement, which are the two insanely counter-intuitive and strange things about QM.
After that (or instead of that, if you know calculus), you might want to watch this one:
Modern Physics: Quantum Mechanics
For this one you need a little bit of calculus, but you get to play with the Schrodinger equation and see where exactly the Heisenberg's Uncertainty Principle comes from (at least math of it).
Exactly.
The problem is not that adding support to a new board in Linux is too hard, in fact, it's almost the opposite. There are already tens of slightly incompatible boards to support, and every time a company makes a new one, they don't even try to stick to any standard (not that there even *exists* a real standard), since it's very easy to just add new code to Linux. See this LKML thread for Linus's description of the problem from some time ago.
Using a microkernel doesn't help at all; you still have to code for all of the slight incompatibilities, regardless of whatever differences in logical organization.
What does your favorite language do in this case? Does its memory model have a local stack concept at all? I guess I'm not sure how any other language with a local stack model would implement this without promoting the variable to long-lived storage.
That depends heavily on the language and possibly on how you choose to implement it.
Lua 5, for example, "lifts" the variable from the stack to the heap when a closure referencing it survives the block where it was created (it calls the variables that are closed over "upvalues"). It's not problematic as C++ because you can't get the address of a variable (so it doesn't matter when the address changes). Scheme and Lisp have many different implementations that vary wildly: from the "lifting" that Lua does to letting the variable live on the stack frame where it was created, and garbage collect stack frames the same way heap is garbage collected (see here). I'm not familiar with other language and/or implementation strategies, but I'm sure there are many more ways to do it, and many variations over what I just mentioned.
Is this really a case of C++ not providing the equivalent to some other language or is it instead a case of extra C++ functionality that doesn't map onto another language's memory model well. In C++11 one can certainly create closures over objects that are global, on the heap, etc. and pass them around at will.
Well, even ignoring the fact that you can't really close over variables that are on the stack (because you can "close over" stuff on the heap by making the lambda reference the pointer by value -- I assume that this is what you mean by "create closures over objects that are on the heap"), as far as I can tell closures lose a lot of usefulness when you don't have garbage collection. Just as a quick example (I'm sure this isn't the best example, but it's all I can think of right now), closures are great for setting up ad-hock event handling, with some objects shared by a few event handlers belonging to a window. That would be very awkward in C++, because you'd have to make sure someone is responsible for deleting the objects when the event handlers disappear (one would probably end up having to subclass the window and add the objects to its list of members, and then you'd have to make sure the right original window's methods are virtual, etc.).
Um...you can. Thus the whole bit about capture lists. std::function is your friend.
No, you can't -- not when it would matter for C++ lambdas to be equivalent to other language's closures. The "while bit about capture lists" is there, in part, to specify exactly when you can.
From the standard, pages 89-90:
If one or more names in the effective capture set are preceded by &, the effect of invoking a closure object or a copy after the innermost block scope of the context of the lambda expression has been exited is undefined.
So, when the lambda actually "closes over" a variable (not just capturing its value), you can't use it outside the block where it was defined. That's unsurprising, since it would mean keeping the stack alive or "lifting" the variable from the stack into the heap, which would open a whole new can of worms.
When people say that a language has closures, they mean that a closure is a first class object: in particular, you should be able to return it from the function/method where it was created.
You could argue that being able to return a lambda would be very un-C++-like, and I tend to agree -- it feels like returning a pointer to a stack variable (in fact, it would be something close to that, if the lambda captures a stack variable). You could argue that returning a lambda would be mostly useless in C++ (I'd disagree, but whatever). You could even argue about the semantics of the name "closure", and whether it should imply being a first class object.
But don't fool yourself into thinking that C++'s lambda is equivalent to what's called a "closure" in other languages; it's not.
The only way we could have true randomness is if there are some sort of measurable phenomena that cannot be predicted. Quantum mechanics dances around this question, and even if there is a state change that is genuinely random, it would be difficult bordering on heroic to measure it in a practical way so as to create a random number generator.
Actually, there are many commercial devices that use quantum effects to generate sequences of numbers that are unpredictable even in theory. Or, if you're careful about it, you can even use a simple Geiger counter to generate truly random data.
Are you asking if there's really a C-to-JavaScript translator? If so, then yes:
https://github.com/kripken/emscripten/wiki
Whoa, thank you very much! At first look, it seems be exactly what I need! Now it seems I'll have to get used to Maxima's way of doing things. :)
And indeed, Maxima is even included with Sage, although I don't know what exactly Sage uses it for...
The general formula for a circle does not favor Pi or Tau but the general formula for finding an area for simple shapes does favor Tao.
I disagree. I don't think it "favors" tau or pi, I think the choice is arbitrary. Before you start thinking I'm an idiot, or simply trying to be difficult just to maintain the status quo, please read my whole explanation.
The example of calculating the area of the circle in The Tau Manifesto does an integral with the radius going from 0 to r. When dealing with a circle, if you think in terms of the radius (as opposed to the diameter), tau is more natural: this is unsurprising, since The Tau Manifesto itself defines it as tau=C/r. Obviously, when dealing of a circle, you think about the diameter (and not the radius), then pi is more natural: pi=C/d.
When you compare the integral (using the radius) with the other simple integrals from physics, you may get a sense of discovering an underlying pattern (in Table 3 (page 16) everything has the exact same formula structure) and all of a sudden everything seems to fit in place. It begins to look like it's obvious that you should choose to work with the radius, and not the diameter. Most of the feeling that tau is "simply better" or "more natural" seems to come from this realization (and other similar ones in the other examples in the Manifesto).
I claim that this is misleading, and it simply isn't true that "the general formula for finding an area for simple shapes does favor Tao". It just happens that, coincidentally, there's a simple way to calculate the area of the circle that integrates over the radius. But if you wanted to calculate the area of a square, or of a triangle, or, even better, some arbitrary shape, the simplest thing to do would NOT be to pick a point inside the shape and integrate over some "rings" (or whatever shape) while moving away from this point to the edge of the shape. Moreover, it is a coincidence that this way to calculate the area of the circle (integrating using the radius, which favours tau) works as beautifully as it does -- it doesn't look as good in any larger dimension (volume, etc.).
But that's just one example. There are many others, usually just silly or misleading in some other way. As for the claim that everywhere you see pi in a formula it's always multiplied by 2, that's just silly.
Still, I already said I agree that tau is better in some places. For example, e^(i*tau) looks more natural than e^(2*i*pi), for the exact same reason that sin(x)=sin(x+2*pi): in the "natural" definition of the trigonometrical functions, 2*pi is "one full circle back to the same point". But that seems to be the only real argument. It's been obvious for a very long time and it doesn't seem reason enough to justify a massive change in the way we write these things. Gratuitous incompatibility is bad!
Yes, I never disagreed that sometimes it makes more sense to use tau. Still, I play a lot with complex arithmetic (by hand! [1]) when learning quantum computation. I've never had a single instance where absorbing the "2" into a constant (tau) would make things dramatically simpler.
The main point, though, is that people seem to make it a bigger deal about it than what it is. It's just a constant. Sometimes it makes more sense (in a "pure" sort of way) to use tau -- especially in really simple examples, it seems. Sometimes, it makes more sense to use pi. Most of the time, though, it doesn't really matter, since there are other constants involved either way. It seems that the benefits of using a single standard (pi is already established) seems to vastly outweigh the trouble of getting used to another constant.
[1] BTW, if anyone knows where I can find some easy-to-use free software that deals *symbolically* with complex matrices -- in particular, multiplying, inverting and calculating eigenvalues and eigenvectors, I'd LOVE hear about it. I mostly use Sage (it's what I ended up using after searching a bit a few years ago), but I end up doing a lot by hand because it seems to refuse to deal with complex numbers in any sensible way -- it doesn't like to keep constants like pi or sqrt(2), and replaces them with inexact floating point values. Mathematica seems to do the right thing -- is there some free software that does the same?
There's no question that "The Tau Manifesto" makes valid points that tau makes more sense than pi in some settings.
Still, I'm a little astounded by all the people that treat this as some profound insight. "The Tau Manifesto" itself is written in a tongue-in-cheek way, and it fits: it's not meant to be taken too seriously. At least, I never thought it was. The examples are hand-picked to make tau look good, and even among them, some are not fully developed: if they were, the arguments would fall apart.
Take the example of the area of the circle. If you generalize for n dimensions, all the talk about comparing it to formulas in physics (uniform acceleration, potential energy, etc.) to justify the 1/2 factor (which would be an argument for using pi) disappears: the general formula doesn't favor either pi or tau, it has ugly constants with both of them (it could even be argued that it looks better with pi).
And what's the point of saying "Tau fixes that in all cases I am aware of (If you know any it does not please post them)"? Things like this might go well in discussions about religion, not math.
Hmmm... I don't think it's that simple.
As far as I understand, you can download and change OpenJDK (it's GPL v2), but if you want to distribute your version without fear of being sued for patent infringement, you must make sure your own version (i.e., OpenJDK plus you changes) passes the TCK -- that is, you must prove to Oracle that it's really "Java", and not some other language that's slightly incompatible with it.
TCK, of course, is not open. When you ask Oracle for the TCK, they want to know what you will do with it (see here), and they are free to deny it or put any restrictions they want on it.
Not without explicit permission from the autors; Snes9x license explicitly forbids it:
Snes9x is freeware for PERSONAL USE only. Commercial users should seek permission of the copyright holders first. Commercial use includes, but is not limited to, charging money for Snes9x or software derived from Snes9x, including Snes9x or derivatives in commercial game bundles, and/or using Snes9x as a promotion for your commercial product. [my emphasis]