Given here are a series of files giving representative Bell inequalities, each of which represents a facet class of Bell inequalities. We use "class" to refer to all inequalities equivalent up to relabelling of inputs/outputs/parties. All scenarios considered here are two party, and are labelled (m_A, m_B, n_A ,n_B) to refer to the number of inputs for Alice (m_A) and Bob (m_B), and outputs per measurement for Alice (n_A) and Bob (n_B). For any given (m_A, m_B, n_A, n_B) scenario, there are several available files, which we shall go through here. All of these are compatible with Mathematica, using the following code: ReadInput=OpenRead["FileName"]; FileData=Read[ReadInput]; Close[ReadInput]; However, all files are stored in simple plaintext, so should be importable into any other program, as long as the list structure (denoted with curly braces) is correctly interpreted. The "Inequalities_Only" files are also available as matlab files, denoted by the .mat extension and can be imported using the code: FileData=load('FileName.mat'); The bottom of this Read_Me file contains some simple examples to help users extract the information they require. For each scenario, the following files are available - we denote the scenario as <>: ----------------------------------------------------------------------------------------------------------------------------------------------------- Inequalities_Only_<>_Raw ---------------------------------------------------------------------------------------------------------------------------------------------------- After loading the file into mathematica using the code above, the variable "FileData" will be a list of the following form: {B_1, B_2, B_3, ...} where each B_i is a Bell inequality representative given by a (m_A*n_A) x (m_B* n_B) matrix, which satisfies Tr[(B_i)^T P]>=1, for all local distributions. (where P is a (m_A n_A) x (m_B n_B) matrix of conditional probabilities p(ab|xy)as explained in the paper). To obtain the ith inequality, having imported the file into Mathematica as described above, one can use the following command: FileData[[i]] which will return the ith element of the list, B_i. To view the matrix more clearly, one can use the following command: FileData[[i]]//MatrixForm which will print on-screen an easy to view matrix. The file is named "Raw" as the inequality matrices are as they were obtained from the linear program. If using the matlab version of this file (given by the extension .mat), one can choose to isolate a relevant inequality i with the following command: FileData.Expressioni ----------------------------------------------------------------------------------------------------------------------------------------------------- Inequalities_Only_<>_Affine ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {B_1, B_2, B_3, ...} All commands described above can be applied to this file also. The only difference between the "Raw" and "Affine" versions is that each inequality has been scaled such that whilst Tr[B^TP]>=1 is still the local bound, the next lowest local deterministic value is 2. (We call this an affine transformation/scaling). This is done by adding a uniform constant to input pair (x,y)=1 and rescaling the entire matrix. ----------------------------------------------------------------------------------------------------------------------------------------------------- Indexed_Raw_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{B_1,1}, {B_2,2}, {B_3,3}, ...} This file contains a list of lists, each of which has two elements. Element 1 is the Bell inequality representative matrix, identical to the one in the file "Inequalities_Only_<>_Raw" Element 2 is the position of this matrix in the list given by "Inequalities_Only_<>_Raw" This file can be useful if you want to re-order the inequalities, whilst still keeping track of their original positions. ----------------------------------------------------------------------------------------------------------------------------------------------------- Indexed_Affine_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{B_1,1}, {B_2,2}, {B_3,3}, ...} This file has the same form as the the "Raw" version, except the matrices are sourced from "Inequalities_Only_<>_Affine" instead. ----------------------------------------------------------------------------------------------------------------------------------------------------- Reduced_Raw_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{B_1,{{n_1A1,n_1A2,...}, {n_1B1,n_1B2,...}}}, {B_2,{{n_2A1,n_2A2,...}, {n_2B1,n_2B2,...}}}, ...} In this file, each representative inequality has been "reduced" - all inputs and outputs which correspond to liftings have been removed. It also gives the first input/scenario for which it appears as a facet inequality class. This is a list of lists, each of which has two elements. Element 1: The reduced inequality as a matrix (note this matrix is no longer (m_A*n_A) x (m_B*n_B) ). Element 2: A list of two vectors {{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}} The first vector corresponds to Alice, and the second to Bob. Each number represents a new input, with that number of outputs (so n_iA1 means the number of outputs for Alice's first measurement for the ith inequality in the list). The inequalities have been relabelled such that these vectors are in the same ascending order as presented in the main body of the paper. ----------------------------------------------------------------------------------------------------------------------------------------------------- Reduced_Affine_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{B_1,{{n_1A1,n_1A2,...}, {n_1B1,n_1B2,...}}}, {B_2,{{n_2A1,n_2A2,...}, {n_2B1,n_2B2,...}}}, ...} In this file, it is the affine matrices which have been "reduced". This does not affect the second element of each list. ----------------------------------------------------------------------------------------------------------------------------------------------------- Indexed_Reduced_Raw_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{{B_1,{{n_1A1,n_1A2,...}, {n_1B1,n_1B2,...}}},1}, {{B_2,{{n_2A1,n_2A2,...}, {n_2B1,n_2B2,...}}},2}, ...} This is a list of lists, each of which has two elements. Element 1: An element identical to that in "Reduced_Raw_<>" (itself consisting of two further components). Element 2: The position of that element within the list described in "Reduced_Raw_<>". The order presented in this file is the same order as in all preeceding files. ----------------------------------------------------------------------------------------------------------------------------------------------------- Indexed_Reduced_Affine_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{{B_1,{{n_1A1,n_1A2,...}, {n_1B1,n_1B2,...}}},1}, {{B_2,{{n_2A1,n_2A2,...}, {n_2B1,n_2B2,...}}},2}, ...} Analogous to the file "Indexed_Reduced_Raw_<>" - except using the elements of "Reduced_Affine_<>" ----------------------------------------------------------------------------------------------------------------------------------------------------- Gathered_Raw_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{{{B_i1,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}}, i1}, {{B_i2,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}}, i2}}, {{{B_j,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}}, j1}, {{B2,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}}, j2}}, ...} In this file, the representative inequalities are grouped by the scenario in which they first appear. The data is in the form of a list of lists, where each list element is itself a list of elements from the file "Indexed_Reduced_Raw_<>", where the two vectors {{n_iA1,n_iA2,...}, {n_iB1,n_iB2, ...}} are the same for all such elements. (Effectively, this file has grouped together the Indexed_Reduced_Raw_<> file by scenario) ----------------------------------------------------------------------------------------------------------------------------------------------------- Gathered_Affine_<> ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{{{B_i1,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}}, i1},{{B_i2,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}}, i2}},{{{B_j,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}}, j1},{{B2,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}},j 2}}, ...} This file has the same information as the above file, except using the affinely scaled matrices (and thus the file "Indexed_Reduced_Affine_<>"). ----------------------------------------------------------------------------------------------------------------------------------------------------- Distinct_Prelifted_Bells_<> (where applicable) ---------------------------------------------------------------------------------------------------------------------------------------------------- Data format: {{{B_i1,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}},{B_i2,{{n_iA1,n_iA2,...}, {n_iB1,n_iB2,...}}}},{{B_j,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}},{B2,{{n_jA1,n_jA2,...}, {n_jB1,n_jB2,...}}}}, ...} For scenarios where the number of outputs per input is more than 2, it is possible to have different facet inequality classes that are in fact different liftings of lower dimensional classes. The files groups reduced representative inequalities by the scenario for which they first appear, AND are unique within that scenario. This file is a list of lists, where each list element is a list of the elements in "Reduced_Affine_<>" - not all elements of "Reduced_Affine_<>" are included, since inequalities that belong to the same class (when reduced) have been removed. This file does not include the original positions in the list "Inequalities_Only_<>_Affine" - as one inequality may correspond to many positions in the list. All of the inequalities are their affine versions. ----------------------------------------------------------------------------------------------------------------------------------------------------- Examples ---------------------------------------------------------------------------------------------------------------------------------------------------- These examples are included to help those unfamiliar with Mathematica Example 1) I wish to find a representative Bell inequality of the 50th class found in the (3,3,3,3) scenario, and call it "InterestingBell". I want the local bound to be 1, with next local deterministic value 2. I then want to view it as a matrix. Insert the following code into Mathematica: ReadInput=OpenRead["Inequalities_Only_3333_Affine"]; FileData=Read[ReadInput]; Close[ReadInput]; InterestingBell=FileData[[50]] InterestingBell//MatrixForm Example 2) I now want to know, for the same class as considered in example 1, the input/output scenario for which that inequality class first appears. I then want to view the representative inequality as a matrix in that reduced scenario. ReadInput=OpenRead["Reduced_Affine_3333"]; FileData=Read[ReadInput]; Close[ReadInput]; InterestingInfo=FileData[[50]] InterestingScenario=InterestingInfo[[2]] InterestingMatrix=InterestingInfo[[1]] InterestingMatrix//MatrixForm Example 3) Finally, I wish to know how many of the inequalities found for the (3,3,3,3) scenario reduce to the same scenario as example 2), and how many of these reduced inequalities are inequivalent. This problem is slightly harder, so comments are included, denoted by (* and *), to explain the process. ReadInput=OpenRead["Gathered_Affine_3333"]; FileDataOne=Read[ReadInput]; Close[ReadInput]; (*We know we are looking for the list of elements containing the element IndexedInfo={InterestingInfo,50} since the "Gathered_Affine_<>" files are indexed. *) {{ListNumber, ListPosition}}=Position[FileDataOne,IndexedInfo]; Length[FileDataOne[[ListNumber]] (*This tells us how many of our (3,3,3,3) inequalities reduced to the same scenario as our class of interest*) ReadInput=OpenRead["Distinct_Prelifted_Bells_3333"]; FileDataTwo=Read[ReadInput]; Close[ReadInput]; (*A note - the ordering in this file of the scenarios is not the same as in the previous file - so we will first find the scenario of interest.*) ScenarioPositions=Table[FileDataOne[[i]][[1]][[2]],{i,Length[FileDataOne]}] {{NewPosition}}=Position[ScenarioPositions,InterestingScenario] Length[FileDataTwo[[NewPosition]]] (*This will give us the number we are after.*)