
Major quantum computational breakthrough is shaking up physics and maths - jonbaer
https://theconversation.com/major-quantum-computational-breakthrough-is-shaking-up-physics-and-maths-136634
======
magneticnorth
The discussion of this paper on Scott Aaronson's blog is a great way to get a
bit deeper into what was proved and what the implications are:
[https://www.scottaaronson.com/blog/?p=4512](https://www.scottaaronson.com/blog/?p=4512)

~~~
AnotherGoodName
Thank goodness. I don't want to be mean but the originally linked article was
badly written. Eg. A sentence about the halting problem being unsolvable with
a follow on sentence to that opening up that everything could be solved by
computers...

~~~
jessriedel
I noticed the same error you did, and I agree the OP article doesn't tell us
much about why this result is important, but I actually thought the OP article
did a better job of explaining complexity classes at an extremely elementary
level (not relying on what a polynomial is) than other articles I've seen

------
edge17
Can someone offer a layman summary? Very curious but everything at this link
and links in the comments is relatively impenetrable to me.

~~~
mlthoughts2018
RE (recursively enumerable) is the class of decision problems for which a
'yes' answer can be verified by a Turing machine in a finite amount of time.
Keep that pinned in your mind.

IP: The class of decision problems for which a "yes" answer can be verified by
an interactive proof. Here a probabilistic polynomial-time verifier sends
messages back and forth with an all-powerful prover. There are some additional
stipulations about the probability with which the verifier must accept or
reject the prover’s claim.

MIP* is like IP but (a) you can have multiple provers and (b) the provers can
share arbitrarily many entangled qubits.

MIP* = RE

One way to look at this is to think of MIP* as a subset of RE and then RE as a
subset of MIP _. RE being contained within MIP_ * isn’t very surprising - if
it’s already in RE, then just clone a bunch of entangled copies of the
“regular” Turing machine that already verifies “yes” answers in finite time
and you’ve got your no-op MIP* version of the same thing. The hard part here
(and where all the details that make the proof such an impressive achievement
come in) is how to ensure the verifier doesn’t have to just trust the provers,
for any general problem in RE, while still only running in polynomial time to
achieve a certain level of probability of correctness.

MIP* \in RE is weird though.

Any decision problem where a verifier can polynomially verify a “yes” answer
given info from multiple entangled provers must also be a problem where there
exists a “regular” Turing machine that can verify a “yes” answer in finite
time.

What’s surprising is that the “collusion” of multiple entangled provers never
presents the verifier with something they can polynomially verify such that
some other “regular” Turing machine couldn’t.

You don’t “get more” or “get extra” out of their being multiple provers that
can “work together” in a sense. It turns out to be no different than the class
of problems where a “yes” answer was already easy (finite time) to verify.

One careful point to note is that the only place in this where polynomial time
comes into play is the process of the verifier validating a “yes” answer from
the provers in MIP _.

The process of the provers themselves may not be polynomial (though, for “yes”
answers it is clear it must be finite).

RE problems are not necessarily efficiently verifiable. For example the
Halting Problem itself is in RE.

The finite verifier for a “yes” answer is to run for the finite amount of time
it takes to halt for that example. The MIP_ interactive proof could be running
several of those in parallel and just ignore any entanglement and ask each one
“have you halted?” They will all wait around for the finite amount of time it
takes to halt and then say “yes” and the verifier can just check they all said
yes (O(n) where n is number of provers). But again the trick is how to modify
that algorithm so the verifier doesn’t just have to believe the provers, and
the authors of the proof give that explicitly for the Halting Problem on page
154 of the paper.

Side note: it’s really hard writing prose with a term that needs an asterisk
on HN - apologies for weird italics and “MIP” when it should be “MIP*”.

~~~
lisper
> the Halting Problem itself is in RE

This is a little misleading. The set of TMs that halt is in RE. But the
halting problem requires you to construct the _complement_ of this set, and
that is not in RE.

~~~
mlthoughts2018
You are incorrect, in fact the Halting Problem is RE-complete,

[https://en.m.wikipedia.org/wiki/RE_(complexity)](https://en.m.wikipedia.org/wiki/RE_\(complexity\))

~~~
lisper
I don't see how your citation supports your position:

"In computability theory and computational complexity theory, RE (recursively
enumerable) is the class of decision problems for which a 'yes' answer can be
verified by a Turing machine in a finite amount of time."

But the halting problem requires you to produce a YES OR NO answer within a
finite time. That's the whole point.

~~~
mlthoughts2018
It’s right there:

> “ Examples of RE-complete problems: > Halting problem: Whether a program
> given a finite input finishes running or will run forever.”

~~~
lisper
Ah. Well, that's just a mistake. It's a misleading use of the term "the
halting problem." There is a problem which is a variant of the halting problem
which is RE-complete, namely, the problem of determining whether a given
program halts. But that is not THE Halting problem, it is merely _a_ halting
problem. THE Halting Problem is the problem of determining whether a program
halts OR DOES NOT HALT, and THAT problem is famously not in RE.

~~~
krackers
>the problem of determining whether a given program halts. But that is not
_the_ Halting problem

Huh? That is indeed _the_ halting problem. More formally "given some turing
machine H and an input x, decide whether H halts on x." But it is of course
trivially semi-decidable.

>determining whether a program halts _or does not halt_

That is equivalent to the formulation mentioned above, since if we had a
decider W for the halting problem then H(x) halts iff W(H, x) accepts and
halts, and H(x) does not halt iff W(H, x) rejects and halts.

I think your confusion stems from the fact that if we had a decider for the
halting problem, then the halting problem would be in R. But the fact that the
halting problem is undecidable (i.e. not in R) means it is in RE but not co-
RE.

~~~
lisper
You're right. I stand corrected.

Unfortunately, it is too late for me to go back and edit my erroneous comment.

------
magneticnorth
A more technical, but imo very good, blog post explaining this result can be
found here: [https://quantumfrontiers.com/2020/03/01/the-shape-of-mip-
re/](https://quantumfrontiers.com/2020/03/01/the-shape-of-mip-re/)

------
krackers
See also:
[https://news.ycombinator.com/item?id=22083935](https://news.ycombinator.com/item?id=22083935)

------
Causality1
My biggest question about quantum computers is will they ever be generalized
or is that a fundamental impossibility? A hundred years from now are computers
going to have a normal processor for 95% of their workload and a quantum
modules for the other five percent?

~~~
nabla9
Quantum computers are not useful as general purpose computers.

<Φ| they would not provide any speedup for most everyday computations.

<Φ| For many everyday computations where they provide speedup they provide
only quadratic speedup (see Grover's algorithm)

<Φ| They can't interact with the environment when they are doing calculations.

------
brian_herman
We need a Scott Arronson to comment on this.

~~~
Cyphase
[https://www.scottaaronson.com/blog/?p=4512](https://www.scottaaronson.com/blog/?p=4512)

------
supergirl
seeing something explained through an analogy, and such a complex analogy,
makes me rage (interogations, cross examination, wtf)

