NonlocalGameValue

	NonlocalGameValue
	Computes the maximum value of a two-player non-local game
Other toolboxes required	CVX
Related functions	BCSGameValue; BellInequalityMax; NPAHierarchy; XORGameValue
Function category	Nonlocality and Bell inequalities
Usable within CVX?	no

NonlocalGameValue is a function that computes the maximum possible value of a given non-local game under either classical mechanics, quantum mechanics, or general no-signalling theories. In the classical and non-signalling cases, an exact value is computed, whereas the value computed in the quantum case is only an upper bound (found using the NPA hierarchy).

Syntax

NGVAL = NonlocalGameValue(P,V)
NGVAL = NonlocalGameValue(P,V,MTYPE)
NGVAL = NonlocalGameValue(P,V,MTYPE,K)

Argument descriptions

P: A probability matrix whose $(x,y)$-entry gives the probability that the referee asks Alice question $x$ and Bob question $y$.
V: A 4-D array whose $(a,b,x,y)$-entry gives the value awarded to Alice and Bob if they reply with answers $(a,b)$ to questions $(x,y)$.
MTYPE (optional, default 'classical'): A string indicating which type of theory should be used when computing the maximum value of the non-local game. Must be one of 'classical', 'quantum', or 'nosignal'. If MTYPE = 'quantum' then only an upper bound on the non-local game is computed, not necessarily the best upper bound (see the argument K below).
K (optional, default 1): If MTYPE = 'quantum' then this is a non-negative integer indicating what level of the NPA hierarchy should be used when bounding the value of the non-local game. Higher values of K give better bounds, but require more memory and time. Alternatively, K can be a string of a form like '1+ab+aab', which indicates that an intermediate level of the hierarchy should be used, where this example uses all products of 1 measurement, all products of one Alice and one Bob measurement, and all products of two Alice and one Bob measurement. Use plus signs to separate the different categories of products, as above. The first character of this string should always be a number, indicating the base level to use. If MTYPE is anything other than 'quantum' then K has no effect.

Examples

The CHSH inequality

One formulation of the CHSH inequality^[1] is as follows:

A referee asks Alice a question $x \in \{0,1\}$ and Bob a question $y \in \{0,1\}$.
Alice and Bob then reply with answers $a \in \{0,1\}$ and $b \in \{0,1\}$ respectively.
Alice and Bob win if and only if $a \oplus b = xy$.

The optimal probability with which Alice and Bob can win this game in classical, quantum, and no-signalling theories are as follows:

>> d = 2;
>> p = ones(d,d)/d^2;
>> V = zeros(d,d,d,d);
>> for a = 1:d
     for b = 1:d
       for x = 1:d
         for y = 1:d
           if(mod(a+b+x*y,d)==0)
             V(a,b,x,y) = 1;
           end
         end
       end
     end
   end
>> NonlocalGameValue(p,V,'classical')
 
ans =
 
    0.7500
 
>> NonlocalGameValue(p,V,'quantum',1)
 
ans =
 
    0.8536
 
>> NonlocalGameValue(p,V,'nosignal')
 
ans =
 
    1.0000

The CHSH-d inequality

A generalization of the CHSH inequality to higher dimensions is exactly as above, except each of $a,b,x,y$ are taken from the set $\{0,1,\ldots,d-1\}$.^[2] The following code computes the values of the CHSH-3 game:

>> d = 3;
>> p = ones(d,d)/d^2;
>> V = zeros(d,d,d,d);
>> for a = 1:d
     for b = 1:d
       for x = 1:d
         for y = 1:d
           if(mod(a+b+x*y,d)==0)
             V(a,b,x,y) = 1;
           end
         end
       end
     end
   end
>> NonlocalGameValue(p,V,'classical')
 
ans =
 
    0.6667
 
>> NonlocalGameValue(p,V,'quantum',1)
 
ans =
 
    0.7182
 
>> NonlocalGameValue(p,V,'quantum',2)
 
ans =
 
    0.7182
 
>> NonlocalGameValue(p,V,'quantum','2+aab')
 
ans =
 
    0.7124
 
>> NonlocalGameValue(p,V,'nosignal')
 
ans =
 
    1.0000

The Fortnow-Feige-Lovász game

The Fortnow-Feige-Lovász (FFL) game^[3]^[4] is well-known example of a non-local game for which perfect parallel repetition does not hold (i.e., quantum players playing two copies of the game in parallel can do better than they can by playing the games in succession).

The game has binary inputs and outputs, and is defined by the rule that the referee asks Alice and Bob the question pair $(x,y) = (0,0)$, $(0,1)$, or $(1,0)$ with probability $1/3$ each, and Alice and Bob win if and only if their answers satisfy $x \vee a \neq y \vee b$, where $\vee$ denotes the bitwise OR operation.

It is known that both the classical value and quantum value of this game equal $2/3$, which we can verify as follows:

>> p = [1 1;1 0]/3;
>> V = zeros(2,2,2,2);
>> for a = 1:2
       for b = 1:2
           for x = 1:2
               for y = 1:2
                   if(max(x,a) ~= max(y,b))
                       V(a,b,x,y) = 1;
                   end
               end
           end
       end
   end
>> NonlocalGameValue(p,V,'classical')
 
ans =
 
    0.6667
 
>> NonlocalGameValue(p,V,'quantum',1)
 
ans =
 
    0.6667

Parallel repetition

In fact, we can even compute the classical and quantum values of two copies of the FFL game being run in parallel: we simply specify the REPT input argument to be 2:

>> NonlocalGameValue(p,V,'classical',1,2)
 
ans =
 
    0.6667
 
>> NonlocalGameValue(p,V,'quantum',1,2)
 
ans =
 
    0.6667

Indeed, the fact that both of these values also equal $2/3$ is a known fact ^[5]. Note that in the command NonlocalGameValue(p,V,'classical',1,2), the "1" that is provided as the value of K does not do anything: it is simply provided as a placeholder so that we can set REPT = 2 in the next input argument (e.g., we could have just as well entered the command NonlocalGameValue(p,V,'classical',9873,2), and the same calculation would have been carried out).

Source code

Click on "expand" to the right to view the MATLAB source code for this function.

%%  NONLOCALGAMEVALUE    Computes the maximum value of a two-player non-local game

%   This function has two required input arguments:

%     P: a matrix whose (x,y)-entry is the probability that the referee

%        asks Alice question x and Bob question y

%     V: a 4-D array whose (a,b,x,y)-entry is the value given to Alice and

%        Bob when they provide answers a and b respectively to questions x

```
%        and y.
```
```
%
```

%   NGVAL = NonlocalGameValue(P,V) is the maximum value that the specified

%   non-local game can take on in classical mechanics. For the maximum

%   quantum or no-signalling value, see the optional arguments described

```
%   below.
```
```
%
```

%   This function has three optional input arguments:

%     MTYPE (default 'classical'): one of 'classical', 'quantum', or

%       'nosignal', indicating what type of nonlocal game value should be

%       computed. IMPORTANT NOTE: if MTYPE='quantum' then only an upper

%       bound on the non-local game value is computed, not its exact value

```
%       (see the argument K below).
```

%     K (default 1): if MYTPE='quantum', then K is a non-negative integer

%       or string indicating what level of the NPA hierarchy to use to

%       bound the non-local game (higher values give better bounds, but

%       require more computation time). See the NPAHierarchy function for

%       details. If MTYPE is anything else, then K is simply ignored.

%     REPT (default 1): the number of times that the non-local game should

%       be played in parallel (i.e., the number of repetitions of the

```
%       game).
```
```
%
```

%   NGVAL = NonlocalGameValue(P,V,MTYPE,K,REPT) is the maximum value that

%   the specified non-local game can take on in the setting (classical,

%   quantum or no-signalling) specified by MTYPE.

```
%
```

%   URL: http://www.qetlab.com/NonlocalGameValue

```
 
```

%   requires: CVX (http://cvxr.com/cvx/), NPAHierarchy.m, opt_args.m,

```
%             update_odometer.m
```
```
%
```

%   author: Nathaniel Johnston (nathaniel@njohnston.ca)

%           Mateus Ara�jo (wrote classical value computation)

```
%   package: QETLAB
```
```
%   last updated: May 29, 2020
```
```
 
```

function ngval = NonlocalGameValue(p,V,varargin)

```
 
```

    % set optional argument defaults: MTYPE='classical', K=1, REPT=1

    [mtype,k,rept] = opt_args({ 'classical', 1, 1 },varargin{:});

```
 
```
```
    % Get some basic values.
```
```
    [ma,mb] = size(p);
```
```
    oa = size(V,1);
```
```
    ob = size(V,2);
```
```
 
```

    % Are we playing the game multiple times? If so, adjust p and V

```
    % accordingly.
```
```
    if(rept > 1)
```

        % Create the new probability array.

```
        p = Tensor(p,rept);
```
```
 
```

        % Create the new winning output array (this is more complicated

        % since MATLAB doesn't have any built-in functions for tensoring

```
        % together 4D arrays).
```

        V2 = zeros(oa^rept,ob^rept,ma^rept,mb^rept);

```
        i_ind = zeros(1,rept);
```
```
        j_ind = zeros(1,rept);
```
```
        for i = 1:ma^rept
```
```
            for j = 1:mb^rept
```
```
                for l = rept:-1:1
```

                    to_tensor{l} = V(:,:,i_ind(l)+1,j_ind(l)+1);

```
                end
```

                V2(:,:,i,j) = Tensor(to_tensor);

```
 
```

                j_ind = update_odometer(j_ind,mb*ones(1,rept));

```
            end
```

            i_ind = update_odometer(i_ind,ma*ones(1,rept));

```
        end
```
```
        V = V2;
```
```
 
```
```
        % Update some computed values.
```
```
        ma = ma^rept;
```
```
        mb = mb^rept;
```
```
        oa = oa^rept;
```
```
        ob = ob^rept;
```
```
    end
```
```
 
```

    % The no-signalling maximum is just implemented by taking the zero-th

    % level of the NPA (quantum) hierarchy.

```
    if(strcmpi(mtype,'nosignal'))
```
```
        mtype = 'quantum';
```
```
        k = 0;
```
```
    end
```
```
 
```

    % Compute the maximum value of the non-local game, depending on which

```
    % type of maximum was requested.
```
```
    if(strcmpi(mtype,'quantum'))
```
```
        cvx_begin quiet
```
```
            variable q(oa,ob,ma,mb);
```

            maximize sum(sum(p.*squeeze(sum(sum(V.*q,1),2))))

```
            subject to
```
```
                NPAHierarchy(q,k) == 1;
```
```
        cvx_end
```
```
 
```
```
        ngval = cvx_optval;
```
```
 
```
```
        % Deal with error messages.
```

        if(strcmpi(cvx_status,'Inaccurate/Solved'))

            warning('NonlocalGameValue:NumericalProblems','Minor numerical problems encountered by CVX. Consider adjusting the tolerance level TOL and re-running the script.');

        elseif(strcmpi(cvx_status,'Inaccurate/Infeasible'))

            warning('NonlocalGameValue:NumericalProblems','Minor numerical problems encountered by CVX. Consider adjusting the tolerance level TOL and re-running the script.');

        elseif(strcmpi(cvx_status,'Unbounded') || strcmpi(cvx_status,'Inaccurate/Unbounded') || strcmpi(cvx_status,'Failed'))

            error('NonlocalGameValue:NumericalProblems',strcat('Numerical problems encountered (CVX status: ',cvx_status,'). Please try adjusting the tolerance level TOL.'));

```
        end
```
```
    elseif(strcmpi(mtype,'classical'))
```

        % Compute the classical maximum value just by looping over Bob's strategies

        % and taking Alice's optimal strategy for each.

```
        for x=1:ma
```
```
            for y=1:mb
```

                V(:,:,x,y) = p(x,y)*V(:,:,x,y);

```
            end
```
```
        end
```
```
        ngval = -Inf;
```
```
        b_ind = zeros(1,mb);
```

        if (oa^ma < ob^mb) % we choose Bob as the party with the fewest strategies

```
            V = permute(V,[3,4,1,2]);
```
```
            [oa,ob,ma,mb] = size(V);
```
```
        end
```

        V = permute(V,[1 3 2 4]); % this is necessary to avoid having to call squeeze later

```
 
```

        if (ob^mb <= 10^6)  % for small problems we don't parallelize

```
           parallel_threads = 0;
```
```
        else
```
```
           parallel_threads = Inf;
```
```
        end
```
```
 
```

        parfor (i = 0:ob^mb-1, parallel_threads)

            b_ind = integer_digits(i,ob,mb);

```
            Valice = zeros(oa,ma);
```
```
            for y=1:mb
```

                Valice = Valice + V(:,:,b_ind(y)+1,y);

```
            end
```
```
            tgval = sum(max(Valice));
```
```
            ngval = max(ngval, tgval);
```
```
        end
```
```
    else
```

        error('NonlocalGameValue:InvalidMTYPE','MTYPE must be one of ''classical'', ''quantum'', or ''nosignal''.');

```
    end
```
```
end
```
```
 
```

% converts number "number" to base "base" with digits "digits"

function dits = integer_digits(number,base,digits)

```
    dits = zeros(1,digits);
```
```
    for i=1:digits
```

        dits(digits+1-i) = mod(number,base);

```
        number = floor(number/base);
```
```
    end
```
```
end
```

Notes

In practice, K probably can't be any larger than 4 when MTYPE = 'quantum', due to memory and time restrictions.
When MTYPE = 'classical', the game's value is computed via the algorithm (which is faster than naive brute force) presented in ^[6].

References

↑ J.F. Clauser, M.A. Horne, A. Shimony, R.A. Holt. Proposed experiment to test local hidden-variable theories. Phys. Rev. Lett., 23(15):880–884, 1969.
↑ M. Howard. Maximum nonlocality and minimum uncertainty using magic states. E-print: arXiv:arXiv:1501.05319 [quant-ph], 2015.
↑ U. Feige, L. Lovász, In Proceedings of the 24th ACM STOC, pages 733-744, 1992.
↑ L. Fortnow, PhD thesis, Massachusetts Institute of Technology, Technical Report MIT/LCS/TR-447, May 1989.
↑ R. Cleve, W. Slofstra, F. Unger, and S. Upadhyay. Perfect parallel repetition theorem for quantum XOR proof systems. Computational Complexity, 17:282–299, 2008. E-print: arXiv:quant-ph/0608146
↑ M. Araújo, F. Hirsch, and M. T. Quintino. Bell nonlocality with a single shot. E-print: arXiv:2005.13418

[1] J.F. Clauser, M.A. Horne, A. Shimony, R.A. Holt. Proposed experiment to test local hidden-variable theories. Phys. Rev. Lett., 23(15):880–884, 1969.

[2] M. Howard. Maximum nonlocality and minimum uncertainty using magic states. E-print: arXiv:arXiv:1501.05319 [quant-ph], 2015.

[3] U. Feige, L. Lovász, In Proceedings of the 24th ACM STOC, pages 733-744, 1992.

[4] L. Fortnow, PhD thesis, Massachusetts Institute of Technology, Technical Report MIT/LCS/TR-447, May 1989.

[5] R. Cleve, W. Slofstra, F. Unger, and S. Upadhyay. Perfect parallel repetition theorem for quantum XOR proof systems. Computational Complexity, 17:282–299, 2008. E-print: arXiv:quant-ph/0608146

[6] M. Araújo, F. Hirsch, and M. T. Quintino. Bell nonlocality with a single shot. E-print: arXiv:2005.13418

[1]

[2]

[3]

[4]

[5]

[6]

NonlocalGameValue

Contents

Syntax

Argument descriptions

Examples

The CHSH inequality

The CHSH-d inequality

The Fortnow-Feige-Lovász game

Parallel repetition

Source code

Notes

References

Navigation menu

Personal tools

Namespaces

Variants

Views

Actions

Search

Navigation

Tools