Quantum proof systems for iterated exponential time, and beyond - - PowerPoint PPT Presentation

Quantum proof systems for iterated exponential time, and beyond

Joe Fitzsimons (SUTD) Zhengfeng Ji (UT Sydney) Thomas Vidick (CalTech)

Henry Yuen

University of Toronto

Motivating question

What is the computational complexity of nonlocal games?

Nonlocal games

• Nonlocal two-player game ! = ($, &):
• Classical verifier interacts with two

non-communicating players

• Verifier samples questions (, ) ∼ $

sends ( to one player, ) to the other

• Players respond with answers + and ,
• Players win if & (, ), +, , = 1.

x

y a b

verifier Player B Player A

Example: CHSH game

• Questions and answers are bits
• Players win if ! ⊕ # = % ∧ '
• Classical value: ( )*+* = 3/4
• Entangled value: (∗ )*+* = cos3

4 5

≈ .854

• One of the most important classical tests of

quantum behavior

• Loophole-free Bell tests
• Device-independent quantum cryptography

x

y a b

|;⟩

verifier Player B Player A

Nonlocal games

• Textbook strategy for the CHSH game is simple
• Players share an EPR pair

! "

00 + |11⟩

• Player A measures observables ( or ), player B measures (( ± ))/ 2.
• This is the unique optimal strategy:
• Any quantum strategy that achieves entangled value /∗ 1232 − 5 must be 6( 5)

close to this textbook strategy, up to local isometries.

• This is called CHSH game rigidity.
• Other nonlocal games
• Magic Square game (/ 73 = 8/9, /∗ 73 = 1, 2 EPR pairs)
• 3-player GHZ game (/ ;2) = 3/4, /∗ ;2) = 1, GHZ state)

Motivating question

What is the complexity of this problem? Given a !-player nonlocal game ", compute #∗ " ± &.

Games " = (), +) can be described in two ways:

• Explicit form: all joint probabilities of ) are given, and + is given as truth table.
• Implicit form: the verifier is described as a circuit/randomized Turing Machine.

The complexity of classical games

Classical value of a (two-player) game !: The supremum is over deterministic strategies for the players. Since the question/answer alphabets are finite, there is a trivial brute force algorithm to compute " ! . " ! = s%&

':)→+ ,:-→.

/

0,2

3 4, 5 ⋅ 7(4, 5, 9 4 , : 5 )

The complexity of classical games

Game description Approximation Complexity Reference Explicit 1/#$%&(() NP-complete Cook-Levin theorem (‘70s) Implicit Ω 1 NEXP-complete MIP=NEXP (late ‘80s) Explicit Ω 1 NP-complete PCP Theorem (‘90s)

NEXP: nondeterministic exponential time

The complexity of approximating the classical value of games is extremely important to theoretical computer science.

The complexity of nonlocal games

Entangled value of a (two-player) game !: The supremum is over all dimensions ", bipartite states # , and measurement

• perators for both players. I.e., ∑% &'

% = ∑) *+ ) = , for all -, /.

0∗ ! = s34

56789:6;9 5 < ∈ℂ?⊗ℂ? ABCD: EF

G ,{IJ K}

M

',+,%,) C ',%,+,) NO

P -, / ⋅ ⟨#|&'

% ⊗ *+ )|#⟩

The space of quantum strategies is infinite. There is no a priori upper bound on the dimension needed to win any game optimally. Unclear if there’s a brute force algorithm to estimate 0∗ ! .

Why study this question?

• Understanding quantum correlations
• Is it possible to algorithmically optimize over the set of quantum correlations?
• Are there nice mathematical characterizations of this set?
• Complexity of quantum proof systems
• What is the computational power of the class !"#∗?
• Applications to quantum information theory and cryptography
• Algorithms for optimizing over quantum correlations are useful in

device-independent cryptography.

• Connections to deep conjectures in mathematics
• The computability of the entangled value of games is implied by positive

resolutions to Tsirelson’s problem and Connes’ Embedding Conjecture.

Our main result

Theorem: For all ! " , the problem of determining whether a given nonlocal game # satisfies

• $∗ # = 1 or
• $∗ # ≤ 1 − Ω

+ , - .

is hard for nondeterministic time 2, - under polynomial-time reductions.

Some fine print:

• ! " must be “time-computable.”
• Hardness holds only for games with at least 15 players (but probably can be reduced to 5)

Prior work

• Kempe-Kobayashi-Matsumoto-Toner-Vidick 2011:
• It is NP-hard to approximate !∗ # ±

% &'()(+) when # is given explicitly.

• Nontrivial: does not follow from the NP-hardness of classical games.
• Problem: Entanglement could help players convince the verifier to accept,

even though it should reject!

• Solution: verifier runs a game is immunized against entanglement.
• Natarajan-Vidick 2018:
• It is QMA-hard under randomized reductions to approximate !∗ # ±

%

• .
• Also called “Quantum PCP Theorem for Games.”

Prior work

• Zhengfeng Ji 2017:
• Approximating !∗ # ±

% &'() * when # is given explicitly is hard for NEXP.

• Recall the complexity of deciding whether a classical game # has

value 1 is NP-complete.

• An exponential separation between the complexities of classical and nonlocal

games!

Prior work

• Zhengfeng Ji 2017:
• Approximating !∗ # ±

% &'() * when # is given explicitly is hard for NEXP.

• Proved using a protocol compression technique
• Compresses a nonlocal game into an equivalent one that is exponentially

smaller, but gap also shrinks.

• However, can only compress once.
• The starting point of our result.

Prior work

• William Slofstra 2016:
• It is undecidable to determine whether !∗ # = 1 for general

games #.

• Proved via an intricate, but beautiful, method to embed the word

problem for groups into a two-player nonlocal game.

• We give a different proof of this result.

Prior work

Accuracy Lower bound Reference Ω(1) QMA-hard Natarajan-Vidick ‘18 1/&'()(*) NEXP-hard Ji ‘17 = 1 vs. < 1 undecidable Slofstra ‘16

Complexity lower bounds for nonlocal games

Prior work

Accuracy Lower bound Reference Ω(1) QMA-hard Natarajan-Vidick ‘18 1/&'()(*) NEXP-hard Ji ‘17 +/,(-) ./012[4, - ]-hard This result = 1 vs. < 1 undecidable Slofstra ‘16

Complexity lower bounds for nonlocal games

Compressing quantum protocols

Ji’s Compression Theorem

There exists a poly time transformation where

• Input: !-player, "-round quantum interactive protocol # where verifier runs in

poly()) time.

• Output: (! + 7)-player nonlocal game - with
• Has message length O log ) and size 0123 )
• If 4∗ # = 1, then 4∗ - = 1
• If 4∗ # ≤ 1 − :, then 4∗ - ≤ 1 −

; <=>?(@).

# has gap :

• has gap :/0123()).

Generalization of nonlocal games where verifier exchanges quantum messages over "-rounds with the players.

Protocol circuits

Protocol circuit for !-player, "-round quantum interactive protocol (! = 2, " = 1)

&

'

&

(

)

'

)( |0⟩

)

'’s private registers

)(’s private registers Verifier’s private registers Messages to/from )

'

Messages to/from )( [Kempe, et al. ‘08] Every quantum interactive protocol can be transformed into an equivalent 1-round protocol.

Protocol circuits

Protocol circuit for !-player, "-round quantum interactive protocol (! = 2, " = 1)

&

'

&( |0⟩

&

'’s private registers

&(’s private registers Verifier’s private registers Messages to/from &

'

Messages to/from &( [Kempe, et al. ‘08] Every quantum interactive protocol can be transformed into an equivalent 1-round protocol.

Protocol history states

• Let ! be protocol circuit of size " = poly()).
• The output of Ji’s Compression Theorem is a game + that checks if

the players share a history state of the circuit !.

, = 1 " + 1 /

012 3

4 ⊗ 606078 ⋯ 68|,2⟩

<

8

<

=

>

8

>= Phase Unitaries Locality <

8

68, … , 6A 2 qubit gates >

8

6AB8 unbounded >= 6AB= Unbounded <

=

6ABC, … , 63 2 qubit gates

|,2⟩

Checking protocol history states

• Idea of history state comes from Kitaev’s proof that the

local Hamiltonians problem is QMA-complete.

• Quantum computations can be encoded into history states.
• History states can be checked via local measurements.
• Main idea of compression: run a “games” version of history state test.
• Introduce extra “trusted” player !" to simulate the verifier of #.
• New verifier $′ asks players !

&, !(, !" to measure their local state and check

they share a history state of #.

• Furthermore, check if the shared state encodes an accepting history of #.
• This game has O(log .)-length questions.

Checking protocol history states

• Idea of history state comes from Kitaev’s proof that the local

Hamiltonians problem is QMA-complete.

• Quantum computations can be encoded into history states.
• History states can be checked via local measurements.
• Main idea of compression: run a “games” version of history state test.
• Introduce extra “trusted” player !" to simulate the verifier of #.
• New verifier $′ asks players !

&, !(, !" to measure their local state and check

they share a history state of #.

• Furthermore, check if the shared state encodes an accepting history of #.
• This game has O(log .)-length questions.

Issue 1: how can we trust the players’ measurements? Issue 2: protocol circuit # involves non-local “gates” (i.e. players’ actions)

Certifying the measurements

• Use the rigidity of nonlocal games.
• Some nonlocal games, like the CHSH game and the Magic Square game,

force the players to use certain types of states and measurements.

• Idea: split up the trusted player !" into 7 players !"#, … , !"&.
• Each qubit of the original player !

"’s state will be encoded using a 7-qubit quantum

error correcting code, and each “share” is distributed to the 7 players.

• Through rigidity of specific nonlocal games, !

"#, … , ! "& are forced to simulate ! "

honestly.

• Idea inspired by results of [RUV’12] and [FV’15] on delegated quantum

computation.

Why not iterate compression scheme?

• Consider language ! that requires (e.g.) doubly exponential time.
• Let " be instance of size #, solvable in time 2% with & = 2(.
• Step 1: [Ito-Vidick] There is a 3-player multiround protocol )

* such that

• Verifier runs in time poly(&)
• If " ∈ !, then 2∗ )

* = 1

• If " ∉ !, then 2∗ )

* ≤ 1 − 8 9:;< % = 1 − 8 =>?(()

• Step 2: [Ji] Compress to game @* of size & with gap

8 9:;< % = 8 =>? ( .

• Step 3: [Ji] Compress to game @*

A of size O log & = DEFG(#) with gap 8 =>? ( .

Problem: Steps 1 and 2 require poly & = exp(J # ) time processing. Problem: Final game has 3+7+7 = 17 players.

Succinct encoding of quantum protocols

• For iterated compression, the input and output of the Compression

Theorem need to be succinct encodings of protocol circuits.

• A succinct encoding of a size ! protocol circuit " is a Turing machine

#$ that computes the description of the %-th gate &' in ()*+*), ! time.

• .

#$ %

Issue: How can a polylog(N)-time machine “know” what a poly(N) circuit looks like?

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

$ %

&

%' %( ⋯

Original *-player protocol

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

$′

&

'

&( &) ⋯

Compressed (, + .)-player protocol with trusted &0

&0

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

Compressed (% + ')-player protocol

)*+ ⋯ )

• ).

)/ ⋯ )*-

0′

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

Compressed (% + ')-player protocol

)*+ )

,

)- ). ⋯ )*,

0′

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

Compressed (% + ')-player protocol

)

*

)+ ), ⋯ )./ ).*

0′

Player merging

• The Compression Theorem, even with

succinct encodings, still increases the number of players by 7.

• Can iterate a small number of times, but

won’t allow us to prove Slofstra’s undecidability result, which requires an infinite number of compression steps.

• We show how to avoid this via

player merging:

• Assume ! = 7

Compressed, merged $-player protocol

%

&/%'&

⋯ %)/%') %*/%'+

,′

Player merging

• The merged player !"/!#" pretends to

be both !" as well as !#".

• In general, merging players is a bad

idea for nonlocal games!

• Special features of the original protocol

make this OK.

• We add tests to check that each !"/!#" is

really acting with a “split-brain”

• Merged player !"/!#" cannot use question

meant for !#" to influence answer for !"’s question

Compressed, merged $-player protocol

!

%/!#%

⋯ !'/!#' !(/!#)

*′

Our Compression Theorem

There exists a poly time transformation where, for all ! ≥ 7

• Input: Succinct encoding of !-player, $-round quantum interactive protocol %

where verifier runs in poly(+) time.

• Output: Succinct encoding of !-player nonlocal game - such that
• The verifier runs in time O(log +).
• If 0∗ % = 1 − 5, then 0∗ - = 1 −

6 789:(;).

Obtaining our lower bound

Theorem: For all ! " , determining whether a game # satisfies $∗ # = 1

• r

$∗ # ≤ 1 − Ω

+ , - .

is hard for nondeterministic time 2, - .

• Imagine that ! " = exp(4) " = exp exp ⋯ exp(") ⋯
• 7 iterated exponentials
• Instead of starting with a “big” verifier and compressing 7 times, we started

with a “small” verifier that uncompresses itself 7 times.

Obtaining our lower bound

• Let ! be language requiring time exp(&) ( .
• There exists a deterministic Turing Machine ) that
• runs in time exp(&) (
• ) * = 1 ⇔ * ∈ !.

A self-referential verifier

Gödel’s Verifier(instance !, verifier size ")

• If " ≥ %( ! ), then compute '(!). If ' ! = 1, accept. Otherwise, reject.
• Otherwise, play the game *+ output by the Compression Theorem applied to the

protocol performed by Gödel’s Verifier(!, 2+).

• GV(!, ") has succinct encoding and runs in time poly(").
• Let 12,+ denote value of game played by GV(!, ").
• We know that 12,4(5) = '(!).
• From compression theorem, we have for all "

12,+ = 1 −

789:,;< =>(<) .

A self-referential verifier

• !",$(&) = )(*).
• For all +, !",, = 1 −

/012,34 56(4) .

• If ) * = 1, then for all +, we have !",, = 1
• If ) * = 0, then !",, ≤ 1 −

/ 9:;<($ & ).

To get this to work for languages in =>?)@ 2$ & , need to use the protocol of [Ji ‘17] or [Natarajan-Vidick ’18] for the final verifier GV(*, B(C)).

QED

Alternate proof of Slofstra’s Theorem

Cantor’s Verifier(instance !, verifier size ")

• Run ! for " steps. If ! halts, reject.
• Otherwise, play the game $% output by the Compression Theorem applied to the

protocol performed by Cantor’s Verifier(!, 2%).

• Similar proof shows that deciding whether Cantor’s Verifier(!, 1) has value 1 is

equivalent to determining whether ! halts or not.

• Slofstra’s Theorem: there is no algorithm to determine whether a nonlocal

game has value 1 or less than 1.

• We reduce to the Halting Problem. Let ! denote a Turing Machine.

Improving the compression theorem?

Improving our compression theorem?

• Our compression theorem has a tradeoff between the size

compression vs the gap compression.

• Verifier complexity is reduced from ! to "(log !)
• Gap is reduced from ( to (/!
• Could there be a better tradeoff? For example, could we achieve the

following?

• Verifier complexity is reduced from ! to "(log !)
• Gap is reduced from ( to (/!* for some small + ≪ 1
• This would have dramatic consequences!

Improving our compression theorem?

• Suppose we had a Hypothetical Compression Theorem™:
• Verifier complexity is reduced from ! to "(log !)
• Gap is reduced from ( to (/!* for some small + ≪ 1
• Idea: use parallel repetition to boost the gap to constant, but we still get a size

reduction!

• Theorem [Bavarian-Vidick-Y. ’17]: Given a .-player game / such that

0∗ / = 1 − 4, there exists a .-player game /5 such that

• Complexity of verifier of /5 is 6 times the complexity of verifier of /
• 0∗ /5 ≤ 1 − 48 9(5)

Improving our compression theorem?

• Using the parallel repetition theorem of BVY, we get a Boosted Hypothetical

Compression Theorem™:

• Verifier complexity is reduced from ! to !"
• Gap stays unchanged at #
• Consequence #1: $%&∗ contains all computable languages
• Consequence #2: $%&∗ contains undecidable languages
• Consequence #3: there is no algorithm to estimate the value of nonlocal games

up to constant accuracy.

Improving our compression theorem?

• Corollary: the tensor product model of quantum correlations is

not equal to the commuting operator model of quantum correlations.

• This is a long standing open problem known as “Tsirelson’s problem”
• Proof: If the tensor product model = commuting operator models, then there

exists an algorithm to estimate the value of nonlocal games via the SDP hierarchies of Navascues, et al. and Doherty, et al.

• This verges on refuting Connes’ Embedding Conjecture, open since 1976.
• It is known that Connes’ Embedding Conjecture is equivalent to Tsirelson’s problem for two

players, but unclear if it holds for more players.

• Our results hold for 14 players. Can probably be brought down to ~5, but would need new

ideas to reduce to 2.

QED

Open questions

• Reduce number of players needed by compression theorem?
• Improve the tradeoff for compression theorem?
• The Quantum PCP for games by Natarajan-Vidick could be useful.
• More applications of the player merging technique?

⋯

Thanks!