toqito.nonlocal_games.quantum_hedging¶
Semidefinite programs for obtaining values of quantum hedging scenarios.
Module Contents¶
- class toqito.nonlocal_games.quantum_hedging.QuantumHedging(q_a, num_reps)[source]¶
Calculate optimal winning probabilities for hedging scenarios.
Calculate the maximal and minimal winning probabilities for quantum hedging to occur in certain two-party scenarios [@Arunachalam_2017_QuantumHedging, Molina_2012_Hedging].
Examples
This example illustrates the initial example of perfect hedging when Alice and Bob play two repetitions of the game where Alice prepares the maximally entangled state:
- [
u = frac{1}{sqrt{2}}|00rangle + frac{1}{sqrt{2}}|11rangle,
]
and Alice applies the measurement operator defined by vector
- [
v = cos(pi/8)|00rangle + sin(pi/8)|11rangle.
]
As was illustrated in [@Molina_2012_Hedging], the hedging value of the above scenario is (cos(pi/8)^2 approx 0.8536)
```python exec=”1” source=”above” import numpy as np from toqito.states import basis from numpy import kron, cos, sin, pi, sqrt, isclose from toqito.nonlocal_games.quantum_hedging import QuantumHedging
e_0, e_1 = basis(2, 0), basis(2, 1) e_00, e_01 = kron(e_0, e_0), kron(e_0, e_1) e_10, e_11 = kron(e_1, e_0), kron(e_1, e_1)
alpha = 1 / sqrt(2) theta = pi / 8 w_var = alpha * cos(theta) * e_00 + sqrt(1 - alpha ** 2) * sin(theta) * e_11
l_1 = -alpha * sin(theta) * e_00 + sqrt(1 - alpha ** 2) * cos(theta) * e_11 l_2 = alpha * sin(theta) * e_10 l_3 = sqrt(1 - alpha ** 2) * cos(theta) * e_01
q_1 = w_var @ w_var.conj().T q_0 = l_1 @ l_1.conj().T + l_2 @ l_2.conj().T + l_3 @ l_3.conj().T
molina_watrous = QuantumHedging(q_0, 1)
# cos(pi/8)**2 approx 0.8536 print(np.around(molina_watrous.max_prob_outcome_a_primal(), decimals=2)) ```
This example demonstrates strong duality with matching primal and dual values, as can be seen below:
```python exec=”1” source=”above” import numpy as np from toqito.states import basis from numpy import kron, cos, sin, pi, sqrt, isclose from toqito.nonlocal_games.quantum_hedging import QuantumHedging
e_0, e_1 = basis(2, 0), basis(2, 1) e_00, e_01 = kron(e_0, e_0), kron(e_0, e_1) e_10, e_11 = kron(e_1, e_0), kron(e_1, e_1)
alpha = 1 / sqrt(2) theta = pi / 8 w_var = alpha * cos(theta) * e_00 + sqrt(1 - alpha ** 2) * sin(theta) * e_11
l_1 = -alpha * sin(theta) * e_00 + sqrt(1 - alpha ** 2) * cos(theta) * e_11 l_2 = alpha * sin(theta) * e_10 l_3 = sqrt(1 - alpha ** 2) * cos(theta) * e_01
q_1 = w_var @ w_var.conj().T q_0 = l_1 @ l_1.conj().T + l_2 @ l_2.conj().T + l_3 @ l_3.conj().T
molina_watrous = QuantumHedging(q_0, 1) print(np.around(molina_watrous.max_prob_outcome_a_dual(), decimals=2)) ```
and
```python exec=”1” source=”above” import numpy as np from toqito.states import basis from numpy import kron, cos, sin, pi, sqrt, isclose from toqito.nonlocal_games.quantum_hedging import QuantumHedging
e_0, e_1 = basis(2, 0), basis(2, 1) e_00, e_01 = kron(e_0, e_0), kron(e_0, e_1) e_10, e_11 = kron(e_1, e_0), kron(e_1, e_1)
alpha = 1 / sqrt(2) theta = pi / 8 w_var = alpha * cos(theta) * e_00 + sqrt(1 - alpha ** 2) * sin(theta) * e_11
l_1 = -alpha * sin(theta) * e_00 + sqrt(1 - alpha ** 2) * cos(theta) * e_11 l_2 = alpha * sin(theta) * e_10 l_3 = sqrt(1 - alpha ** 2) * cos(theta) * e_01
q_1 = w_var @ w_var.conj().T q_0 = l_1 @ l_1.conj().T + l_2 @ l_2.conj().T + l_3 @ l_3.conj().T
molina_watrous = QuantumHedging(q_0, 1) print(np.around(molina_watrous.min_prob_outcome_a_primal(), decimals=2)) ```
```python exec=”1” source=”above” import numpy as np from toqito.states import basis from numpy import kron, cos, sin, pi, sqrt, isclose from toqito.nonlocal_games.quantum_hedging import QuantumHedging
e_0, e_1 = basis(2, 0), basis(2, 1) e_00, e_01 = kron(e_0, e_0), kron(e_0, e_1) e_10, e_11 = kron(e_1, e_0), kron(e_1, e_1)
alpha = 1 / sqrt(2) theta = pi / 8 w_var = alpha * cos(theta) * e_00 + sqrt(1 - alpha ** 2) * sin(theta) * e_11
l_1 = -alpha * sin(theta) * e_00 + sqrt(1 - alpha ** 2) * cos(theta) * e_11 l_2 = alpha * sin(theta) * e_10 l_3 = sqrt(1 - alpha ** 2) * cos(theta) * e_01
q_1 = w_var @ w_var.conj().T q_0 = l_1 @ l_1.conj().T + l_2 @ l_2.conj().T + l_3 @ l_3.conj().T
molina_watrous = QuantumHedging(q_0, 1) print(np.around(molina_watrous.min_prob_outcome_a_dual(), decimals=2)) ```
- Parameters:
q_a (numpy.ndarray)
num_reps (int)
- max_prob_outcome_a_primal()[source]¶
Compute the maximal probability for calculating outcome “a”.
The primal problem for the maximal probability of “a” is given as:
- [
- begin{equation}
- begin{aligned}
- text{maximize:} quad & langle Q_{a_1} otimes ldots
otimes Q_{a_n}, X rangle \
- text{subject to:} quad & text{Tr}_{mathcal{Y}_1 otimes
ldots otimes mathcal{Y}_n}(X) = I_{mathcal{X}_1 otimes ldots otimes mathcal{X}_n},\ & X in text{Pos}(mathcal{Y}_1 otimes mathcal{X}_1 otimes ldots otimes mathcal{Y}_n otimes mathcal{X}_n)
end{aligned}
end{equation}
]
- Returns:
The optimal maximal probability for obtaining outcome “a”.
- Return type:
float
- max_prob_outcome_a_dual()[source]¶
Compute the maximal probability for calculating outcome “a”.
The dual problem for the maximal probability of “a” is given as:
- [
- begin{equation}
- begin{aligned}
text{minimize:} quad & text{Tr}(Y) \ text{subject to:} quad & pi left(I_{mathcal{Y}_1 otimes ldots otimes mathcal{Y}_n} otimes Y right) pi^* geq Q_{a_1} otimes ldots otimes Q_{a_n}, \ & Y in text{Herm} left(mathcal{X} otimes ldots otimes mathcal{X}_n right)
end{aligned}
end{equation}
]
- Returns:
The optimal maximal probability for obtaining outcome “a”.
- Return type:
float
- min_prob_outcome_a_primal()[source]¶
Compute the minimal probability for calculating outcome “a”.
The primal problem for the minimal probability of “a” is given as:
- [
- begin{equation}
- begin{aligned}
- text{minimize:} quad & langle Q_{a_1} otimes ldots
otimes Q_{a_n}, X rangle \
- text{subject to:} quad & text{Tr}_{mathcal{Y}_1 otimes
ldots otimes mathcal{Y}_n}(X) = I_{mathcal{X}_1 otimes ldots otimes mathcal{X}_n},\ & X in text{Pos}(mathcal{Y}_1 otimes mathcal{X}_1 otimes ldots otimes mathcal{Y}_n otimes mathcal{X}_n)
end{aligned}
end{equation}
]
- Returns:
The optimal minimal probability for obtaining outcome “a”.
- Return type:
float
- min_prob_outcome_a_dual()[source]¶
Compute the minimal probability for calculating outcome “a”.
The dual problem for the minimal probability of “a” is given as:
[ begin{equation}
- begin{aligned}
text{maximize:} quad & text{Tr}(Y) \ text{subject to:} quad & pi left(I_{mathcal{Y}_1 otimes ldots otimes mathcal{Y}_n} otimes Y right) pi^* leq Q_{a_1} otimes ldots otimes Q_{a_n}, \ & Y in text{Herm} left(mathcal{X} otimes ldots otimes mathcal{X}_n right)
end{aligned}
end{equation} ]
- Returns:
The optimal minimal probability for obtaining outcome “a”.
- Return type:
float