`BellScenario.ConvexPolytope`

— ModuleThis BellComm submodule provides methods for polyhedral analysis and transformations.

`BellScenario.Nonlocality`

— Module*Find the optimal parameters for quantum Bell violations.*

The `Nonlocality.jl`

module provides tools to optimize quantum non-locality in Bell scenarios.

**Module Exports:**

`optimize_measurement`

: Finds the quantum measurement which violates a specified Bell inequality maximally.

`BellScenario.Nonlocality.optimize_measurement`

— Method`BipartiteNonSignaling`

scenario:

```
optimize_measurement(
game :: BellGame,
scenario :: BipartiteNonSignaling,
ρ_AB :: AbstractMatrix;
A_POVMs :: Vector{<:AbstractVector{<:AbstractMatrix}},
) :: Dict
```

Find Bob's measurement which optimizes a `BellGame`

's score for the shared quantum state `ρ_AB`

and POVM measurement applied by Alice. The following semi-definite program optimizes the Bob's POVM:

\[\begin{aligned} &\max_{\{\Pi_b^y\}} \sum_{a,b,x,y} G_{a,b,x,y}\text{Tr}[(\Pi_a^x \otimes \Pi_b^y)\rho_{AB}] \\ &s.t. \quad \sum_b \Pi_b^y = \mathbb{I},\quad \Pi_b^y \geq 0 \quad \forall\; y \end{aligned}\]

```
optimize_measurement(
game :: BellGame,
scenario :: BipartiteNonSignaling,
ρ_AB :: AbstractMatrix;
B_POVMs :: Vector{<:AbstractVector{<:AbstractMatrix}},
) :: Dict
```

Find Alice's measurement which optimizes a `BellGame`

's score for the shared quantum state `ρ_{AB}`

and POVM measurement applied by Bob. The following semi-definite program optimizes the Alice's POVM:

\[\begin{aligned} &\max_{\{\Pi_a^x\}} \sum_{a,b,x,y} G_{a,b,x,y}\text{Tr}[(\Pi_a^x \otimes \Pi_b^y)\rho_{AB}] \\ &s.t. \quad \sum_a \Pi_a^x = \mathbb{I},\quad \Pi_a^x \geq 0 \quad \forall \;x \end{aligned}\]

`BellScenario.Nonlocality.optimize_measurement`

— Method`LocalSignaling`

scenario:

```
optimize_measurement(
scenario :: LocalSignaling,
game :: BellGame,
ρ_states :: Vector{<:AbstractMatrix}
)
```

Finds the measurement that optimizes the score of the `BellGame`

against the set of quantum states `ρ_states`

. The optimization is performed with the following semi-definite program:

\[\begin{aligned} &\max_{\{\Pi_y\}} \sum_{x,y} G_{x,y} \text{Tr}[\Pi_y \rho_x] \\ &s.t. \quad \sum_y \Pi_y = \mathbb{I}, \quad \Pi_y \geq 0 \end{aligned}\]

`BellScenario.LocalPolytope`

— Module*Compute the bounds of classical Bell scenarios.*

The `LocalPolytope.jl`

module provides tools for characterizing the convex polyhedral structure of the correlations attainable using classical resources in a Bell scenario.

Each distinct strategy for a given Bell scenario corresponds to a point in vector space. The complete set of attainable strategies for a particular Bell scenario is denoted $\mathbf{P}$. Given the constraints of normalization and non-negativity, the extreme points of $\mathbf{P}$ correspond to deterministic strategies (matrices with 0,1 elements). Furthermore, when shared randomness is used in a Bell scenario, any two strategies can be mixed together in a convex combination. Hence, $\mathbf{P}$ is a convex polyhedron referred to as the *local polytope*.

A convex polytope has two equivalent descriptions:

**V-Description**: The polytope is the convex hull of a set of extreme points known as vertices $\mathbf{V}$, $\quad\mathbf{P} = \text{conv}(\mathbf{V})$.**H-Description**: The polytope is the intersection of a set of linear half-spaces known as facets $\mathbf{F}$, $\quad\mathbf{P} = \cap\mathbf{F}$.

These two descriptions are equivalent,

\[\mathbf{P} = \text{conv}(\mathbf{V}) = \cap\mathbf{F},\]

and there exists a transformation between the set of vertices and facets $\mathbf{V} \leftrightarrow \mathbf{F}$.

For a given Bell scenario, the V-Description is typically easier to compute, however, the H-Description describes the bounds of the local polytope as as linear inequalities known as Bell inequalities. Bell inequalities are important because they provide a simple test to verify that a strategy is not contained by the local polyotpe. That is, if a Bell inequality is violated, the classical resources considered for the local polytope are not sufficient to reproduce the strategy. Hence, a Bell violation witnesses the use of resources with greater operational value. Bell violations are often used to characterize the advantages of quantum resources, however, it is important to note that a Bell violation can simply mean that more classical resources were used than anticipated.

**Module Exports:**

`vertices`

- Compute the set of extreme-points for the local polytope.`num_vertices`

- The number of vertices for the local polytope.`vrep`

- Construct a`Polyhedron`

in the vertex representation.`facets`

- Compute the linear inequalities which bound the local polytope.`generator_vertex`

- Provide a canonical form for a vertex.`generator_facet`

- Provide a canonical form for a facet.`adjacency_decomposition`

- Efficiently compute the generator facets for the local polytope using the adjacency decomposition technique.

`BellScenario.LocalPolytope._perm_increase_lexico_score`

— MethodHelper function for `generator_facet`

.

`BellScenario.LocalPolytope.adjacency_decomposition`

— Method```
adjacenecy_decomposition(
vertices :: Vector{Vector{Int64}},
BG_seed :: BellGame,
scenario :: LocalSignaling;
kwargs...
) :: Dict
```

Given a polytpe represented by `vertices`

, returns the complete set of canonical facets for prepare and measure scenario `scenario`

. The adjacency*decomposition algorithm requires a seeded vertex which is supplied with the `BG*seed` argument. Facets are returned in the lexicographic normal form.

**Returned Dictionary Format**

Returns a dictionary where the keys are canonical `BellGames`

and the value is a dictionary with keys

- "considered" => true, if the facet was considered in the algorithm.
- "skipped" => true, if the facet was skipped (not considered).
- "num_vertices" => number of vertices.
- "norm_facet" => facet vector representative (normalized rep) of canonical game

**Keyword Arguments: kwargs...**

`skip_games = [] :: Vector{BellGame}`

- List of games to skip.`max_vertices = 100 :: Int64`

- The maximum number of vertices to allow in target facets.`dir`

= "./" :: String`- Directory in which to create`

porta_tmp/`and`

.json` files.`log = false :: Bool`

- If true, the facet dictionary is written to`.json`

each iteration.`log_filename = "adjacency_decomposition_now.json" :: String`

`BellScenario.LocalPolytope.adjacent_facets`

— Method```
adjacent_facets(
vertices :: Vector{Vector{Int64}},
F :: Vector{int64};
dir = "./" :: String,
cleanup = true ::Bool
) :: Vector{Vector{Int64}}
```

For the polytope represented by `vertices`

, returns the set of facets adjacent to `F`

.

Facet vector `F`

and the return facet vectors are assumed to ba in the normalized subspace.

The `dir`

argument specifies where to where to write files and directories from XPORTA.jl. If `cleanup`

is `true`

, then a porta_tmp directory is created as a subdirectory of `dir`

.

If `cleanup`

is `false`

, the created `porta_tmp`

directory is not removed.

`BellScenario.LocalPolytope.dimension`

— Method`dimension( vertices :: Vector{Vector{Int64}} ) :: Int64`

For the provided vertices (points), finds the dimension of the affine space spanned by the vertices. This method computes the dimension of a polytope, facet, or collection of points.

This also accepts matrices and `DeterministicStrategy`

types as arguments:

```
dimension( vertices :: Vector{Matrix{Int64}} ) :: Int64
dimension( vertices :: Vector{DeterministicStrategy} ) :: Int64
```

`BellScenario.LocalPolytope.facet_to_matrix`

— Method`facet_to_matrix(num_in, num_out, gen_facet)`

transforms the vector form of a facet to the minimal matrix with non-negative elements.

`BellScenario.LocalPolytope.facets`

— Method`facets(poly::Polyhedron) :: Vector{Vector{Int64}}`

Returns the facets of the local polytope `poly`

. If the facets have not already been computed, then they are transformed into the half-space representation from the vertex representation.

`BellScenario.LocalPolytope.facets`

— Method```
facets(
vertices :: Vector{Vector{Int64}};
dir = "./" :: String,
cleanup=true :: Bool
) :: Dict{String, Vector{Vector{Int64}}}
```

Computes the facet inequalities and equalities which bound the convex polyhedron defined by the set of `vertices`

. If the optimal representation is used for the vertices, then no equalitities will be present. For example, if the "generalized" vertex representation is used the normalization constraints will be included in the resulting equalities. The output of this method is structured:

```
Dict(
"facets" => inequalities, # :: Vector{Vector{Int64}}
"equalitites" => equalities, # :: Vector{Vector{Int64}}
)
```

Facet inequalities and equalities are represented as single vector `f`

where `f[1:(end-1)]`

contains the coefficients of the linear inquality and `f[end]`

is the bound. Facet inequalities and equalities act upon a vertex `v`

where inequalities are arranged such that there is an implicit `f[1:(end-1)]' * v ≤ f[end]`

and equalities are arranged such that `f[1:(end-1)]' * v == f[end]`

Vertex -> facet transformations are notoriously difficult computational problems. The performance limits of this method will be met far before the limits the vertex enumeration methods.

`BellScenario.LocalPolytope.generator_facet`

— Method`generator_facet( BG :: BellGame, scenario :: LocalSignaling ) :: BellGame`

Finds the generating facet for the provided `BellGame`

. The generator is provided in lexicographic normal form. The generating facet is found recursively by an algorithm which sorts by lexicographic scores.

`BellScenario.LocalPolytope.generator_vertex`

— Method```
generator_vertex(
D :: DeterministicStrategy,
scenario :: LocalSignaling
) :: DeterministicStrategy
```

Finds the generating vertex for the provided `DeterministicStrategy`

. The generating vertex is the lexicographic normal form of `D`

.

`BellScenario.LocalPolytope.linear_nonclassicality_witness`

— Method```
linear_nonclassicality_witness(
vertices :: Vector{Vector{T}} where T <: Real,
test_behavior :: Vector{<:Real};
verbose=false :: Bool
) :: Vector{Float64}
```

Obtains a linear inequality $(\mathbf{G}^\star, \beta^\star)$ bounding the convex hull of the set of `vertices`

($\mathcal{V}$) and is violated by the `test_behavior`

$(\mathbf{P}\notin \text{Conv}(\mathcal{V}))$. This task is achieved using the linear program described by Brunner et al. in Eq. 19 of https://arxiv.org/abs/1303.2849. The linear program is

\[\begin{align} \min_{(\mathbf{G}, \beta)} \quad & \langle \mathbf{G},\mathbf{P}\rangle - \beta & \notag\\ \text{s.t.} \quad & \langle \mathbf{G}, \mathbf{V} \rangle - \beta \leq 0 & \quad \forall \;\; \mathbf{V} \in \mathcal{V} \notag\\ & \langle \mathbf{G}, \mathbf{P} \rangle \leq 1 & \notag\\ \end{align}\]

The solution to the linear program is a linear nonclassicality witness $(\mathbf{G}^\star, \beta^\star)$ becuase the constraint $\lange\mathbf{G}^\star, \mathbf{V} \rangle - \beta^\star \leq 0$ ensures that no behavior in the polytope $\text{Conv}(\mathcal{V})$ can violate the inequality. Provided that $\mathbf{P} \notin \text{Conv}(\mathcal{V})$ technique the output linear inequality witnesses the nonclassicality of the `test_behavior`

.

The optimized facet inequality $(\mathbf{G}^\star, \beta^\star)$ is returned as a vector $(G^\star_{0,0}, \dots, G^\star_{Y,X}, -\beta^\star)$ where $G^\star_{y,x}$ are the elements of $\mathbf{G}^\star$.

The linear programming software outputs numerical values that have numerical error. Moreover, the linear inequality is scaled such that the classical bound is zero and the `test_behavior`

score is one. In order to convert the output inequality into a `BellGame`

, care must be taken to obtain the correct scaling factor to ensure that elements are integers.

If the `test_behavior`

$\mathbf{P}$ is classical, meaning it satisfies $\mathbf{P}\in\text{Conv}(\mathcal{V})$, then the zero vector is returned as the optimal solution. Note that if all elements of $\mathbf{G}^\star$ satisfy $G^\star_{y,x}=0$, then all behaviors $\mathbf{P} \in \text{Conv}(\mathcal{V})$ are trivially optimal as $\langle\mathbf{G}^{\star}, \mathbf{P} \rangle - \beta^\star \leq 0$.

`BellScenario.LocalPolytope.num_vertices`

— Method`num_vertices( scenario :: BipartiteNonSignaling ) :: Int64`

For two non-signaling black-boxes with $X$ and $Y$ inputs and $A$ and $B$ outputs respectively, the number of vertices $|\mathcal{V}|$ are counted:

\[|\mathbf{V}| = A^X B^Y\]

`BellScenario.LocalPolytope.num_vertices`

— Method`num_vertices( scenario :: BlackBox ) :: Int64`

For $n$ outputs and $m$ inputs the number of vertices $|\mathcal{V}|$ are counted:

\[|\mathbf{V}| = n^m\]

`BellScenario.LocalPolytope.num_vertices`

— Method```
num_vertices( scenario :: LocalSignaling;
rank_d_only = false :: Bool
) :: Int64
```

If `rank_d_only = true`

, then only strategies using `d`

-dits are counted. For $X$ inputs and $Y$ outputs the number of vertices $|\mathcal{V}|$ are counted:

\[|\mathbf{V}| = \sum_{c=1}^d \left\{X \atop c \right\}\binom{Y}{c}c!\]

`BellScenario.LocalPolytope.rotate_facet`

— Method```
rotate_facet(
F :: Vector{Int64},
G :: Vector{Int64},
xbar :: Vector{Int64}
) :: Vector{Int64}
```

Performs a rotation of facet `F`

relative to non-included vertex `xbar`

and returns the rotated facet vector. `F`

is a polytope facet, `G`

is a subfacet of `F`

and `xbar`

is a vertex not contained by `F`

. By construction, the rotated facet contains `xbar`

.

`BellScenario.LocalPolytope.vertex_dims`

— Method`vertex_dims( scenario:: BipartiteNonSignaling, rep :: String ) :: Int64`

Valid values for `rep`

include:

- "non-signaling"
- "normalized"
- "generalized"

`BellScenario.LocalPolytope.vertex_dims`

— MethodFor the given `Scenario`

, returns the length of the vertex in the representation specified by `rep`

. A `DomainError`

is thrown if the `rep`

is invalid.

`vertex_dims(scenario :: Union{BlackBox,LocalSignaling}, rep :: String) :: Int64`

Valid values of `rep`

are `"normalized"`

and `"generalized"`

.

`BellScenario.LocalPolytope.vertices`

— Function```
vertices( scenario :: BipartiteNonSignaling,
rep="non-signaling" :: String
) :: Vector{Vector{Int64}}
```

Enumerates the LocalPolytope vertices for the `BipartiteNonSignaling`

scenario. Valid representations for the vertices include:

`"non-signaling"`

,`"normalized"`

,`"generalized"`

A `DomainError`

is thrown if a valid representation is not specified.

`BellScenario.LocalPolytope.vertices`

— Method```
vertices( scenario :: BlackBox;
rep = "normalized" :: String
) :: Vector{Vector{Int64}}
```

Generates the Local Polytope vertices for a BlackBox scenario. Valid represenations are:

*`rep == "normalized"`

or `rep == "generalized"`

.

`BellScenario.LocalPolytope.vertices`

— Method```
vertices( scenario :: LocalSignaling;
rep = "normalized" :: String
rank_d_only = false :: Bool
) :: Vector{Vector{Int64}}
```

Generates the deterministic strategies for the local polytope of `LocalSignaling`

scenarios. The `rank_d_only`

keyword arg specifies whether to exclude vertices which use fewer dits of communication and thus have a matrix rank less than d.

The vertices computed in this method are vectorized directly from a strategy matrix by column-majorization. These vertices are distinct from those produced by older `LocalPolytope.vertices()`

methods which are row-majorized.

`Polyhedra.vrep`

— Method`vrep(scenario::Scenario; vertices_kwargs...) :: XPORTA.Polyhedron`

Constructs a `Polyhedron`

using the vertex representation. See Polyhedra.jl for more details. The `vertices_kwargs`

keyword arguments are passed through to the `vertices`

function for each `Scenario`

.

This function differs from the Polyhedra.jl implementation in that it returns a `Polyhedron`

type rather than a `V-Representation`

. This is done to reduce the number of steps required to construct a polyhedron.

`BellScenario.BellScenario`

— Module*Types and constructors that represent Bell scenarios, their statistics, and their bounds.*

The BellScenario.jl module is the base library for Bell scenario analysis.

**Features:**

`Scenario`

: abstract type describing Bell scenarios.`AbstractStrategy`

: abstract type for Bell scenario statistics.`AbstractGame`

: abstract type for Bell scenario bounds.

A game theoretic framework is used to evaluate the performance of black-box systems. A cost function testing the black-box system is regarded as a *game* while the statistics generated by the black-box system are regarded as a *strategy*. A strategy is played against a game to achieve a score, hence, this framework provides a quantitative metric of the performance of a black-box system in regards to a particular task.

`BellScenario.AbstractGame`

— TypeAn `AbstractGame`

is the abstract type that is parent to type representing a cost function for strategies. A `Game`

is a linear inequality dual to `Strategy`

matrices, it is represented by a matrix $G$ containing scalar coefficients and a bound $\beta$. The bound of the linear inequality is typically a maximum score attainable by Bell scenario using a certain set of resources. A `Game`

$G$ is played by a `Strategy`

$S$ to achieve a score computed as,

\[\beta \geq \langle G, S\rangle = \sum_{x,y} G_{y,x}S(y|x).\]

The game is "won" if the strategy scores greater than $\beta$, that is, the above inequality is violated. Since $\beta$ is the maximum score for a set of resources, the game is won only if the tested strategy used a set of resources of greater operational value than than considered when computing the bound $\beta$.

Conveniently, `Strategy`

matrices have normalized columns and non-negative elements. This means that any game inequality can be converted into a form where game matrix $G$ has positive elements and $\beta$ designates a positive upper bound.

`BellScenario.AbstractStrategy`

— TypeAn `AbstractStrategy`

is an abstract type parent to all strategy matrices. A black-box device is characterized by its conditional probabilities which can be organized into a strategy matrix or column-stochastic map $S : \mathcal{X} \to \mathcal{Y}$. The strategy matrix $S$ is constructed as follows,

\[S = \sum_{x,y} P(y|x) |y\rangle\langle x|\]

where the elements of a strategy matrix must be non-negative and normalized:

- $P(y|x) \geq 0$
- $\sum_y P(y|x) = 1$

Since strategies are just stochastic matrices, the product of two strategies yields a new strategy, e.g. $S_A*S_B = S_C$.

`*(S1::AbstractStrategy, S2::AbstractStrategy) :: Strategy`

When multiplied together, two strategies may represent a new `Scenario`

, hence, a the multiplication operator can also be passed a `Scenario`

.

`*(S1::AbstractStrategy, S2::AbstractStrategy, scenario::Scenario) :: Strategy`

`BellScenario.BellGame`

— Type`BellGame(game::Matrix{Int64}, β::Int64, scenario::Scenario)`

A `BellGame`

represents a Bell inequality or tight facet of the local polytope. Since the vertices of the local polytope are deterministic strategies with 0,1 elements, the linear inequalities describing facets of the local polytope have rational coefficients. Therefore, if a inequality tightly bounds the local polytope, it can be represented by a game with integer coefficients.

`BellScenario.BipartiteNonSignaling`

— Type```
BipartiteNonSignaling(
A :: Int64,
B :: Int64,
X :: Int64,
Y :: Int64
) <: Scenario
```

A bipartite non-signaling scenario where each device receives an input and produces an output. Let Alice be the device with `A`

outputs and `X`

inputs while Bob is the device with `B`

outputs and `Y`

inputs.

Shared randomness is held between Alice and Bob. When Alice and Bob share quantum entanglement, Bell violations are known to occur.

**Errors**

A `DomainError`

is thrown if `A`

, `B`

, `X`

, or `Y`

is less than 1.

`BellScenario.BipartiteSignaling`

— Type```
BipartiteSignaling(
A :: Tuple{Int64, Int64},
B :: Tuple{Int64, Int64};
dits :: Int64 = 1,
bidirectional :: Bool = false
) <: Scenario
```

A bipartite signaling scenario where each device can send a message to the other.

`BellScenario.BlackBox`

— Type`BlackBox(num_out :: Int64, num_in :: Int64) <: Scenario`

A Bell scenario consisting of a single black-box device with `num_in`

inputs and `num_out`

outputs.

The black-box device computes the output $y$ from the input $x$ by performing a stochastic map $S(y|x)$.

**Errors**

A `DomainError`

is thrown if parameters `num_out`

or `num_in`

is less than 1.

`BellScenario.DeterministicStrategy`

— Type`DeterministicStrategy(conditionals :: Matrix{Int64}) <: AbstractStrategy{Int64}`

A strategy matrix describing the behavior of a deterministic black-box. A strategy *deterministic* if its elements satisfy $P(y|x)\in\{0,1\}$ in addition to the non-negativity and normalization constraints. By default, the constructor creates a strategy for a 'BlackBox' scenario, however, a `Scenario`

can be passed to the `DeterministicStrategy`

constructor.

`DeterministicStrategy(conditionals :: Matrix{Int}, scenario :: Scenario)`

The product of two deterministic strategies is a `DeterministicStrategy`

.

`*(S1::DeterministicStrategy, S2::DeterministicStrategy) :: DeterministicStrategy`

When multiplied a new `Scenario`

can be specified.

```
*(
S1::DeterministicStrategy,
S2::DeterministicStrategy,
scenario::Scenario
) :: Deterministic Strategy
```

**Errors:**

A `DomainError`

is thrown if:

- The provided
`Scenario`

does not match the dimension of the`conditionals`

matrix. - The elements of
`conditionals`

are not`0`

or`1`

. - The strategy elements are not non-negative and normalized.

`BellScenario.Game`

— Type`Game(game::Matrix{T}, β::Real) <: AbstractGame{T}`

A `Game`

is represented by a `Matrix`

of coefficients and a scalar bound `β`

.

Type parameter `T`

can be either `Int64`

or `Float64`

.

`BellScenario.LocalSignaling`

— Type```
LocalSignaling(
X :: Int64,
Y :: Int64,
d :: Int64,
) <: Scenario
```

A bipartite signaling scenario where information is passed from a transmitter black-box to a receiver black-box using no more than `d`

dits of communication.

The transmitter device has `X`

inputs and the receiver device has `Y`

outputs and shared randomness is held between the two devices. When quantum communication is used instead of classical communication no Bell violations occur.

**Errors**

A `DomainError`

is thrown if `X`

, `Y`

, or `d`

is less than 1.

`BellScenario.Scenario`

— TypeA `Scenario`

is an abstract type parent to all Bell scenarios. Each child of this abstract type describes a distinct black-box system configuration.

`BellScenario.Strategy`

— Type```
Strategy(conditionals :: Matrix{<:Real}; atol::Float64 = 1e-7) <: AbstractMatrix{Float64}
Strategy(conditionals :: Conditionals; atol::Float64 = 1e-7) <: AbstractMatrix{Float64}
```

The `conditionals`

parameter is a column stochastic matrix. The `conditionals`

can either be accepted in a raw `Matrix{<:Real}`

format or as a `Conditionals`

type from QBase.jl. The `atol`

parameter expresses the absolute tolerance for numerical error in the constraints of conditional probablities. By default, the constructor creates a strategy for a 'BlackBox' scenario. However, a `Scenario`

can be passed to the `Strategy`

constructor.

`Strategy(conditionals :: Matrix{<:Real}, scenario :: Scenario, atol::Float64=1e-7)`

**Errors:**

A `DomainError`

is thrown if:

- The provided
`Scenario`

does not match the expected dimension of the`conditionals`

matrix. - The
`conditionals`

matrix is not a valid stochastic matrix, e.g. non-negative and normalized.

`Base.convert`

— Method```
convert(
S :: Type{<:AbstractStrategy}, vertex::Vector{<:Real}, scenario::BipartiteNonSignaling;
rep="non-signaling" :: String
)
```

Transforms a behavior vector or vertex in to either a `Strategy`

or `DeterministicStrategy`

. If converting into a `DeterministicStrategy`

, the vertex must contain `Int64`

values. Valid representations are "non-signaling", "normalized", and "generalized".

`Base.convert`

— MethodFacet (`Vector{Int64}`

) -> `BellGame`

```
convert(
::Type{BellGame},
facet::Vector{Int64},
scenario::BipartiteNonSignaling;
rep = "non-signaling"::String
)
```

Transforms LocalPolytope facets into `BellGame`

types.

`Base.convert`

— MethodFacet (`Vector{Int64}`

) -> `BellGame`

```
convert(
::Type{BellGame},
facet::Vector{Int64},
scenario::Union{BlackBox, LocalSignaling};
rep = "normalized"::String
)
```

`Base.convert`

— MethodVertex (`Vector{Int64}`

) -> `DeterministicStrategy`

```
convert(
::Type{DeterministicStrategy},
vertex :: Vector{Int64},
scenario :: Scenario;
rep = "normalized" :: String
)
```

`Base.convert`

— Method`XPORTA.IEQ`

to `BellGame`

's

```
convert(
::Type{Vector{BellGame}},
ieq::IEQ,
scenario::Union{BlackBox, LocalSignaling};
rep = "normalized" :: String
)
```

`Base.convert`

— MethodBellGame -> Vector{Int64}

```
convert(::Type{Vector{Int64}},
BG::BellGame,
scenario::BipartiteNonSignaling;
rep = "non-signaling" :: String
)
```

Transforms a `BellGame`

for a `BipartiteNonSignaling`

scenario into a facet vector.

`Base.convert`

— Method`BellGame`

-> Facet (`Vector{Int64}`

)

`convert(::Type{Vector{Int64}}, BG::BellGame; rep = "normalized" :: String)`

`Base.convert`

— Method`DeterministicStrategy`

-> Vertex (`Vector{Int64}`

)

```
convert(
::Type{Vector{Int64}},
strategy :: DeterministicStrategy;
rep = "normalized" :: String
)
```

`Base.convert`

— Method`BellGame`

's to `XPORTA.IEQ`

`convert(::Type{IEQ}, bell_games::Vector{BellGame}; rep = "normalized" :: String)`

`BellScenario._reverse_game_normalization`

— MethodApplies the normalization constraint to remove all negative values in the provided `game_matrix`

. Returns a tuple `(new_game_matrix, new_bound)`

`BellScenario.base_n_val`

— Method```
base_n_val(
num_array :: Vector{Int64},
base :: Int64;
big_endian=true :: Bool
) :: Int64
```

Given an array representing a number in base-n returns the value of that number in base-10.

Inputs:

`num_array`

- Vector containing semi-positive integers less than base.`base`

- The base-n number represented by num_array.`big_endian`

-`true`

if most significant place is at index 1, else`false`

.

`BellScenario.deterministic_strategies`

— Method```
deterministic_strategies(scenario :: BlackBox) :: Vector{Matrix{Int64}}
deterministic_strategies(num_out :: Int64, num_in :: Int64) :: Vector{Matrix{Int64}}
```

Enumerates the set of deterministic strategies for the specified `BlackBox`

. For performance, enumerated deterministic strategies are left as matrices and not constructed into `DeterministicStrategy`

types.

`BellScenario.is_deterministic`

— Method`is_deterministic( strategy :: AbstractMatrix ) :: Bool`

Returns `true`

if all elements of `strategy`

are either `0`

or `1`

and the matrix is a valid conditional probability distribution.

`BellScenario.n_choose_k_matrices`

— Method`n_choose_k_matrices( n :: Int64, k :: Int64 ) :: Vector{Matrix{Bool}}`

Generates a set of `n`

by `k`

matrices which represent all combinations of selecting `k`

columns from `n`

rows. Each column, contains a single non-zero element and `k`

rows contain a non-zero element.

E.g.

```
julia> n_choose_k_matrices( 4, 2 )
6-element Vector{Matrix{Bool}}:
[1 0; 0 1; 0 0; 0 0]
[1 0; 0 0; 0 1; 0 0]
[1 0; 0 0; 0 0; 0 1]
[0 0; 1 0; 0 1; 0 0]
[0 0; 1 0; 0 0; 0 1]
[0 0; 0 0; 1 0; 0 1]
```

A `DomainError`

is thrown if `n ≥ k ≥ 1`

is not satisfied.

`BellScenario.permutation_matrices`

— Method`permutation_matrices( dim :: Int64 ) :: Vector{Matrix{Bool}}`

Generates the set of square permutation matrices of dimension `dim`

.

E.g.

```
julia> permutation_matrices(3)
6-element Vector{Matrix{Bool}}:
[1 0 0; 0 1 0; 0 0 1]
[1 0 0; 0 0 1; 0 1 0]
[0 1 0; 1 0 0; 0 0 1]
[0 0 1; 1 0 0; 0 1 0]
[0 1 0; 0 0 1; 1 0 0]
[0 0 1; 0 1 0; 1 0 0]
```

`BellScenario.pretty_print_txt`

— Method`pretty_print_txt( bell_games :: Vector{BellGame}, filename :: String )`

Prints a set of `BellGame`

's to `filename.txt`

in a human-readable form.

`BellScenario.quantum_strategy`

— Method`BipartiteNonSignaling`

scenarios:

```
quantum_strategy(
ρ_AB :: AbstractMatrix,
Π_Ax :: Vector{<:AbstractVector{<:AbstractMatrix}},
Π_By :: Vector{<:AbstractVector{<:AbstractMatrix}},
scenario :: BipartiteNonSignaling;
atol::Float64 = 1e-7
)
```

Constructs a strategy matrix in the generalized representation for the quantum system with conditional probabilities.

\[ P(ab|xy) = \text{Tr}[(\Pi_a^x\otimes\Pi_b^y)\rho_{AB}]\]

A `DomainError`

is thrown if

- The length of each POVM does not match the scenarios number of outputs
- The number of each party's POVMS doesn't match the the number of inputs.

`BellScenario.quantum_strategy`

— Method`LocalSignaling`

scenarios:

```
quantum_strategy(
Π :: AbstractVector{<:AbstractMatrix},
ρ_states :: Vector{<:AbstractMatrix},
scenario :: LocalSignaling;
atol=1e-7::Float64
) :: Strategy
```

For quantum systems the conditional probabilities are construct as

\[ P(y|x) = \text{Tr}[\Pi_y\rho_x].\]

A `DomainError`

is thrown if the provided states and measurements are not compatible with the specified scenario.

`BellScenario.quantum_strategy`

— MethodConstructs a strategy matrix given quantum states and measurements. The supported scenarios include:

`BlackBox`

scenarios:

```
quantum_strategy(
Π :: AbstractVector{<:AbstractMatrix},
ρ_states :: Vector{<:State};
atol=1e-7::Float64
) :: Strategy
```

For a quantum system the conditional proabilities are constructed as

\[ P(y|x) = \text{Tr}[\Pi_y\rho_x].\]

`BellScenario.random_strategy`

— Method```
random_strategy(
num_inputs :: Int64,
num_outputs :: Int64;
) :: Strategy
```

Constructs a randomized `Strategy`

matrix. Zeros are inserted into the strategy to ensure that it does not closely resemble a uniform distribution.

`BellScenario.stirling2`

— Method`stirling2( n :: Int64, k :: Int64 ) :: Int64`

Counts the number of ways to partition `n`

items into `k`

unlabelled groups. This quantity is known as Stirling's number of the 2nd kind:

\[\left\{n \atop k \right\} = \frac{1}{k!}\sum_{i=0}^k (-1)^i\binom{k}{i}(k-i)^n\]

Throws a `DomainError`

if inputs do not satisfy `n ≥ k ≥ 1`

.

`BellScenario.stirling2_matrices`

— Method`stirling2_matrices( n :: Int64, k :: Int64 ) :: Vector{Matrix{Bool}}`

Generates the set of matrices with `k`

rows and `n`

columns where rows correspond to the groups and columns are the grouped elements. A non-zero element designates that the column id is grouped into the corresponding row.

E.g.

```
julia> stirling2_matrices(4, 2)
7-element Vector{Matrix{Bool}}:
[1 1 1 0; 0 0 0 1]
[0 0 1 0; 1 1 0 1]
[1 1 0 0; 0 0 1 1]
[1 0 1 0; 0 1 0 1]
[0 1 0 0; 1 0 1 1]
[0 1 1 0; 1 0 0 1]
[1 0 0 0; 0 1 1 1]
```

A `DomainError`

is thrown if `n ≥ k ≥ 1`

is not satisfied.

`BellScenario.stirling2_partitions`

— Method`stirling2_partitions( n :: Int64, k :: Int64 ) :: Vector{Vector{Vector{Int64}}}`

Enumerates the unique partitions of `n`

items into `k`

unlabelled sets. Each partition is a vector containing a set of `k`

vectors designating each group.

E.g.

```
julia> stirling2_partitions(4, 2)
7-element Vector{Vector{Vector{Int64}}}:
[[1, 2, 3], [4]]
[[3], [1, 2, 4]]
[[1, 2], [3, 4]]
[[1, 3], [2, 4]]
[[2], [1, 3, 4]]
[[2, 3], [1, 4]]
[[1], [2, 3, 4]]
```

This recursive algorithm was inspired by this blog.

`BellScenario.strategy_dims`

— Method`strategy_dims( scenario :: Scenario ) :: Tuple{Int64, Int64}`

Returns the dimensions of the `Conditionals`

matrix describing a `Strategy`

for the `Scenario`

at hand. Each `Scenario`

, can place unique constraints on the matrix dimensions, therfore, separate methods are called for each concrete `Scenario`

.