The entanglement model

The entanglement model is a high level and simpler model for Bell state entanglements, which is common used in quantum networks. Instead of using matrix, entanglement models uses fidelity and other parameters to describe an entanglement. Also, this model provide basic quantum operations including entanglement swapping, distillation and teleportation. The advantage is that it simplifies the evaluation by hiding low-level operations and provides higher performance.

In SimQN, multiple quantum nodes may hold the same reference of an entanglement object. For example, if two nodes have the reference of the same entanglement, it means that each of them has a qubit that in this entangled state. Users needs to maintain the fact that an entanglement can not be referenced by more than 2 quantum nodes by themselves.

Three entanglement models

We pre-defined three kinds of entanglements, i.e., the ideal Bell-state entanglement, the Werner state entanglement, and the mixed state entanglement. All models fix the swapping and distillation protocol. Since all of these entanglements are implemented from BaseEntanglement, other entanglement models can also be produced by extend the original BaseEntanglement.

The following codes shows how to produce an entanglement:

from qns.models.epr import WernerStateEntanglement

# produce entanglements e1 and e2
e1 = WernerStateEntanglement(fidelity=0.95, name="e1")
e2 = WernerStateEntanglement(fidelity=0.95, name="e2")

# entanglement swapping using e1 and e2
e3 = e1.swapping(e2)
print(e3.fidelity)

# produce entanglements e4 and e5
e4 = WernerStateEntanglement(fidelity=0.95, name="e4")
e5 = WernerStateEntanglement(fidelity=0.95, name="e5")

# produce entanglements e4 and e5
e6 = e4.swapping(e5)
print(e6.fidelity)

# entanglement distillation (purification) using e3 and 36
e7 = e3.distillation(e6)
print(e7.fidelity)

Ideal Bell State entanglement

In BellStateEntanglement, the quantum state is the max entangled state \(\ket{\Phi^+}\), and the fidelity is fixed to 1 (indicates the max entangled state). The entanglement swapping has probability of success p_swap. For the BellStateEntanglement, no error is introduced during storing and transmission.

Werner State entanglement

In WernerStateEntanglement, the the density matrix is

\[\rho = w \ket{\Phi^+} \bra{\Phi^+} + \frac{1-w}{4} \mathbb{I}_4,\]

where w is the werner parameter and the fidelity is \(f = (3w + 1) / 4\). The entanglement swapping protocol will produce a new entanglement (e3 in the above example), where \(w_3 = w_1 w_2\). SimQN adopt the Bennett96 distillation protocol, where the success probability is

\[f^2+\frac{2}{3}f(1-f) + \frac{5}{9} (1-f)^2\]

, and the final fidelity is

\[f' = \frac{f^2+\frac{1}{9}(1-f)^2}{f^2+\frac{2}{3}f(1-f) + \frac{5}{9} (1-f)^2}\]

For WernerStateEntanglement, the werner parameter will drop during storing in quantum memories or transmitting though quantum channels. After storing for time t, the new state will be \(w' = w \cdot e^{ - \alpha t}\), where \(\alpha\) is the decoy parameter (default is 0). Both t and \(\alpha\) are input parameter of the storage_error_model.

For transmitting error, the new state will be \(w' = w \cdot e^{ - \beta l}\), where \(\beta\) is the decoy parameter (default is 0) and l is the channel length. Both l and \(\beta\) are input parameter of the transfer_error_model.

Most general mixed state entanglement

The third entanglement model is the most general one, as any 2 qubit entanglement can be presented as a mixed state entanglement. A mixed state entanglements has the density matrix as:

\[\rho = a \ket{\Phi^+} \bra{\Phi^+} + b \ket{\Psi^+} \bra{\Psi^+} + c \ket{\Psi^-} \bra{\Psi^-} + d \ket{\Phi^-} \bra{\Phi^-},\]

and the fidelity equals to \(a\). After an entanglement swapping, the new state is:

\[\begin{split}a' = a_1 a_2 + b_1 b_2 + c_1 c_2 + d_1 d_2 \\ b' = a_1 b_2 + b_1 a_2 + c_1 d_2 + d_1 c_2 \\ c' = a_1 c_2 + b_1 d_2 + c_1 a_2 + d_1 b_2 \\ d' = a_1 d_2 + b_1 c_2 + c_1 d_2 + d_1 a_2 \\\end{split}\]

The distillation protocol has the success probability of

\[p = (a_1+d_1)(a_2+d_2) + (b_1+c_1)(b_2+c_2)\]

The final state after distillation is:

\[\begin{split}a' = (a_1 a_2 + d_1 d_2)/p \\ b' = (b_1 b_2 + c_1 c_2)/p \\ c' = (b_1 c_2 + c_1 b_2)/p \\ d' = (a_1 d_2 + d_1 a_2)/p \\\end{split}\]

The error models for mixed state entanglement is \(x = 0.25 + (x-0.25)e^{\alpha t}\), where x can be a, b, c, and d. After enough time, it will decoherence. The transmission error is also x = 0.25 + (x-0.25)e^{beta l}, where l is the channel length. Both \(\alpha\) and \(\beta\) is the attributions of the memories or the channels.

If the error models, swapping protocols and distillation protocols do not fit your need, it is easy to implement your own entanglement model by extend BaseEntanglement.

Quantum teleportation

Both models provides the teleportation protocol to transmit a qubit using the entanglement. Also, It is possible to change an entanglement model to two entangled qubits model:

from qns.models.epr import BellStateEntanglement
from qns.models.qubit.qubit import Qubit
from qns.models.qubit.const import QUBIT_STATE_0

e1 = BellStateEntanglement(fidelity=0.8, name="e1")

# change BellStateEntanglement model to Qubit model
q0, q1 = e1.to_qubits()
print(q0.state)

# execute teleportation protocol to transmit a Qubit
q0 = Qubit(QUBIT_STATE_0) # the transmitting qubit
e1 = BellStateEntanglement(fidelity=0.8, name="e0")

q2 = e1.teleportion(q0) # The transmitted qubit
print(q2.measure())

To present errors in storage or transmission, users can build their own entanglement models by implementing the transfer_error_model and storage_error_model.