Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:1608.04829

Quantum Merlin-Arthur with noisy channel

Tomoyuki Morimae, Keisuke Fujii, Harumichi Nishimura

Published Aug 17, 2016• 5 citations
arXivHTMLPDF

Abstract

What happens if in QMA the quantum channel between Merlin and Arthur is noisy? It is not difficult to show that such a modification does not change the computational power as long as the noise is not too strong so that errors are correctable with high probability, since if Merlin encodes the witness state in a quantum error-correction code and sends it to Arthur, Arthur can correct the error caused by the noisy channel. If we further assume that Arthur can do only single-qubit measurements, however, the problem becomes nontrivial, since in this case Arthur cannot do the universal quantum computation by himself. In this paper, we show that such a restricted complexity class is still equivalent to QMA. To show it, we use measurement-based quantum computing: honest Merlin sends the graph state to Arthur, and Arthur does fault-tolerant measurement-based quantum computing on the noisy graph state with only single-qubit measurements. By measuring stabilizer operators, Arthur also checks the correctness of the graph state. Although this idea itself was already used in several previous papers, these results cannot be directly used to the present case, since the test that checks the graph state used in these papers is so strict that even honest Merlin is rejected with high probability if the channel is noisy. We therefore introduce a more relaxed test that can accept not only the ideal graph state but also noisy graph states that are error-correctable.

DOI
10.48550/arxiv.1608.04829

Related papers

Two-message quantum-Arthur-Merlin game with single-qubit measurements

Tomoyuki Morimae

We show that the class quantum-Arthur-Merlin (QAM) does not change even if the verifier's ability is restricted to only single-qubit measurements. To show the result, we use the idea of measurement-based quantum computing: the verifier, who can do only single-qubit measurements, can test the graph state sent from the prover and use it for his measurement-based quantum computing. Inspired by this construction, we also introduce a problem which we call stabilizer state optimization, and show that it is QMA-complete.

arXiv:1602.08656•Physical Review A•Jun 23, 2016•4 citations

Quantum Merlin-Arthur with Clifford Arthur

Tomoyuki Morimae, Masahito Hayashi, Harumichi Nishimura +1 more

We show that the class QMA does not change even if we restrict Arthur’s computing ability to only Clifford gate operations (plus classical XOR gate). The idea is to use the fact that the preparation of certain single-qubit states, so called magic states, plus any Clifford gate operations are universal for quantum computing. If Merlin is honest, he sends the witness plus magic states to Arthur. If Merlin is malicious, he might send other states to Arthur, but Arthur can verify the correctness of magic states by himself. We also generalize the result to QIP(3): we show that the class QIP(3) does not change even if the computational power of the verifier is restricted to only Clifford gate operations (plus classical XOR gate).

arXiv:1506.06447•Quantum Information and Computation•Nov 1, 2015•4 citations

Quantum proofs can be verified using only single-qubit measurements

Tomoyuki Morimae, Daniel Nagaj, Norbert Schuch

Quantum Merlin Arthur (QMA) is the class of problems which, though potentially hard to solve, have a quantum solution that can be verified efficiently using a quantum computer. It thus forms a natural quantum version of the classical complexity class NP (and its probabilistic variant MA, Merlin-Arthur games), where the verifier has only classical computational resources. In this paper, we study what happens when we restrict the quantum resources of the verifier to the bare minimum: individual measurements on single qubits received as they come, one by one. We find that despite this grave restriction, it is still possible to soundly verify any problem in QMA for the verifier with the minimum quantum resources possible, without using any quantum memory or multiqubit operations. We provide two independent proofs of this fact, based on measurement-based quantum computation and the local Hamiltonian problem. The former construction also applies to ${\mathrm{QMA}}_{1}$, i.e., QMA with one-sided error.

arXiv:1510.06789•Physical Review A•Feb 22, 2016•32 citations

Verifiable Measurement-Only Blind Quantum Computing with Stabilizer Testing

Masahito Hayashi, Tomoyuki Morimae

We introduce a simple protocol for verifiable measurement-only blind quantum computing. Alice, a client, can perform only single-qubit measurements, whereas Bob, a server, can generate and store entangled many-qubit states. Bob generates copies of a graph state, which is a universal resource state for measurement-based quantum computing, and sends Alice each qubit of them one by one. Alice adaptively measures each qubit according to her program. If Bob is honest, he generates the correct graph state, and, therefore, Alice can obtain the correct computation result. Regarding the security, whatever Bob does, Bob cannot get any information about Alice's computation because of the no-signaling principle. Furthermore, malicious Bob does not necessarily send the copies of the correct graph state, but Alice can check the correctness of Bob's state by directly verifying the stabilizers of some copies.

arXiv:1505.07535•Physical Review Letters•Nov 25, 2015•193 citations

On Perfect Completeness for QMA

Scott Aaronson

Whether the class QMA (Quantum Merlin Arthur) is equal to QMA1, or QMA with onesided error, has been an open problem for years. This note helps to explain why the problem is difficult, by using ideas from real analysis to give a "quantum oracle" relative to which QMA ≠ QMA1. As a byproduct, we find that there are facts about quantum complexity classes that are classically relativizing but not quantumly relativizing, among them such "trivial" containments as BQP ⊆ ZQEXP.

•Jun 3, 2008•3 citations

The geometry of quantum computation

Mark R. Dowling, Michael A. Nielsen

Whether the class Quantum Merlin Arthur is equal to QMA_1, or QMA with one-sided error, has been an open problem for years. This note helps to explain why the problem is difficult, by using ideas from real analysis to give a quantum oracle relative to which QMA\neqQMA_1. As a byproduct, we find that there are facts about quantum complexity classes that are classically relativizing but not quantumly relativizing, among them such trivial containments as BQP\subseteq{ZQEXP}.

Quantum Information and Computation•Nov 1, 2008•137 citations
What happens if in QMA the quantum channel between Merlin and Arthur is noisy? It is not difficult to show that such a modification does not change the computational power as long as the noise is not too strong so that errors are correctable with high probability, since if Merlin encodes the witness state in a quantum error-correction code and sends it to Arthur, Arthur can correct the error caused by the noisy channel. If we further assume that Arthur can do only single-qubit measurements, however, the problem becomes nontrivial, since in this case Arthur cannot do the universal quantum computation by himself. In this paper, we show that such a restricted complexity class is still equivalent to QMA. To show it, we use measurement-based quantum computing: honest Merlin sends the graph state to Arthur, and Arthur does fault-tolerant measurement-based quantum computing on the noisy graph state with only single-qubit measurements. By measuring stabilizer operators, Arthur also checks the correctness of the graph state. Although this idea itself was already used in several previous papers, these results cannot be directly used to the present case, since the test that checks the graph state used in these papers is so strict that even honest Merlin is rejected with high probability if the channel is noisy. We therefore introduce a more relaxed test that can accept not only the ideal graph state but also noisy graph states that are error-correctable.
We show that the class quantum-Arthur-Merlin (QAM) does not change even if the verifier's ability is restricted to only single-qubit measurements. To show the result, we use the idea of measurement-based quantum computing: the verifier, who can do only single-qubit measurements, can test the graph state sent from the prover and use it for his measurement-based quantum computing. Inspired by this construction, we also introduce a problem which we call stabilizer state optimization, and show that it is QMA-complete.
We show that the class QMA does not change even if we restrict Arthur’s computing ability to only Clifford gate operations (plus classical XOR gate). The idea is to use the fact that the preparation of certain single-qubit states, so called magic states, plus any Clifford gate operations are universal for quantum computing. If Merlin is honest, he sends the witness plus magic states to Arthur. If Merlin is malicious, he might send other states to Arthur, but Arthur can verify the correctness of magic states by himself. We also generalize the result to QIP(3): we show that the class QIP(3) does not change even if the computational power of the verifier is restricted to only Clifford gate operations (plus classical XOR gate).
Quantum Merlin Arthur (QMA) is the class of problems which, though potentially hard to solve, have a quantum solution that can be verified efficiently using a quantum computer. It thus forms a natural quantum version of the classical complexity class NP (and its probabilistic variant MA, Merlin-Arthur games), where the verifier has only classical computational resources. In this paper, we study what happens when we restrict the quantum resources of the verifier to the bare minimum: individual measurements on single qubits received as they come, one by one. We find that despite this grave restriction, it is still possible to soundly verify any problem in QMA for the verifier with the minimum quantum resources possible, without using any quantum memory or multiqubit operations. We provide two independent proofs of this fact, based on measurement-based quantum computation and the local Hamiltonian problem. The former construction also applies to QMA1{\mathrm{QMA}}_{1}QMA1​, i.e., QMA with one-sided error.
We introduce a simple protocol for verifiable measurement-only blind quantum computing. Alice, a client, can perform only single-qubit measurements, whereas Bob, a server, can generate and store entangled many-qubit states. Bob generates copies of a graph state, which is a universal resource state for measurement-based quantum computing, and sends Alice each qubit of them one by one. Alice adaptively measures each qubit according to her program. If Bob is honest, he generates the correct graph state, and, therefore, Alice can obtain the correct computation result. Regarding the security, whatever Bob does, Bob cannot get any information about Alice's computation because of the no-signaling principle. Furthermore, malicious Bob does not necessarily send the copies of the correct graph state, but Alice can check the correctness of Bob's state by directly verifying the stabilizers of some copies.