Entanglement Distillation -- BBPSSW Protocol¶

Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.

Overview¶

Quantum entanglement plays a vital role in quantum communication, quantum computing, and many other quantum technologies. Therefore, detecting, transmitting, and distributing quantum entanglement reliably are essential tasks if we want to build real applications in those fields. However, errors are inevitable in the real world. They could come from imperfect equipment when we create entanglement (preparation errors), or the quantum channel used to transmit entanglement is noisy, and we gradually lose the degree of entanglement as the transmission distance increases. The aim of entanglement distillation is to compensate for those losses and restore a maximally entangled state at the cost of many noisy entangled states. In this sense, one could also refer entanglement distillation as a purification/error-correction protocol. This process often involves two remote parties Alice and Bob such that only Local Operations and Classical Communication (LOCC) are allowed [1]. The concept of entanglement distillation was first introduced by Bennett et al. [2] in 1996 and the original protocol is known as the BBPSSW protocol following the name of the authors.

The Bell states¶

Many protocols in quantum information processing utilize the Bell states, including quantum teleportation [3], superdense coding [4] and quantum cryptography based on Bell’s theorem [5]. Such an enormous application range makes the four bell states an important subject of study. They are usually defined in the following bi-partite notation,

|Φ±⟩AB=1√2(|0⟩A⊗|0⟩B±|1⟩A⊗|1⟩B),|Ψ±⟩AB=1√2(|0⟩A⊗|1⟩B±|1⟩A⊗|0⟩B).(1)|Φ±⟩AB=12(|0⟩A⊗|0⟩B±|1⟩A⊗|1⟩B),(1)|Ψ±⟩AB=12(|0⟩A⊗|1⟩B±|1⟩A⊗|0⟩B).

where AA (Alice) holds one qubit and BB (Bob) holds the other qubit. They could be physically separated. These states can not be decomposed as a single product state |φ⟩A⊗|ψ⟩B|φ⟩A⊗|ψ⟩B. Note: This is a key feature of entangled pure states.

There is an interesting feature about Bell state that if trace out subsystem AA, the reduced density operator ρBρB will become I/2I/2. For example, let's take a look at the Bell state |Φ+⟩AB|Φ+⟩AB

ρB≡trA(Φ+AB),=trA(|Φ+⟩⟨Φ+|AB),=12trA(|00⟩⟨00|+|00⟩⟨11|+|11⟩⟨00|+|11⟩⟨11|),=12(trA(|0⟩⟨0|A)⋅|0⟩⟨0|B+trA(|0⟩⟨1|A)⋅|0⟩⟨1|B+trA(|1⟩⟨0|A)⋅|1⟩⟨0|B+trA(|1⟩⟨1|A)⋅|1⟩⟨1|B),=12(|0⟩⟨0|B+|1⟩⟨1|B)=12I.(2)ρB≡trA(ΦAB+),=trA(|Φ+⟩⟨Φ+|AB),=12trA(|00⟩⟨00|+|00⟩⟨11|+|11⟩⟨00|+|11⟩⟨11|),=12(trA(|0⟩⟨0|A)⋅|0⟩⟨0|B+trA(|0⟩⟨1|A)⋅|0⟩⟨1|B+trA(|1⟩⟨0|A)⋅|1⟩⟨0|B+trA(|1⟩⟨1|A)⋅|1⟩⟨1|B),(2)=12(|0⟩⟨0|B+|1⟩⟨1|B)=12I.

There exists a non-classical correlation between the entangled qubit pair. We cannot describe the whole system with side information about the sub-systems. One can create the Bell states Φ+ABΦAB+ (density matrix) easily in Paddle Quantum by calling the function bell_state().

In [1]:
import paddle_quantum
from paddle_quantum.state import bell_state

# Change to density matrix mode
paddle_quantum.set_backend('density_matrix')
# Number of qubits
N = 2
rho = bell_state(N)
print("The generated state Phi  = \n", rho)

The generated state Phi  = 
 [[0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]
 [0. +0.j 0. +0.j 0. +0.j 0. +0.j]
 [0. +0.j 0. +0.j 0. +0.j 0. +0.j]
 [0.5+0.j 0. +0.j 0. +0.j 0.5+0.j]]

Entanglement quantification¶

After having a taste of quantum entanglement qualitatively, we want to promote our understanding to a quantitative level. One should realize the validity of aforementioned quantum communication protocols, including quantum teleportation and superdense coding, depends on the quality of the entanglement quantification. Following the convention in quantum information community, the negativity N(ρ)N(ρ) and the logarithmic negativity EN(ρ)EN(ρ) are widely recognized metrics to quantify the amount of entanglement presented in a bi-partite system [6]. Specifically,

N(ρ)≡||ρTB||1−12,(3)(3)N(ρ)≡||ρTB||1−12,

and

EN(ρ)≡log2||ρTB||1,(4)(4)EN(ρ)≡log2||ρTB||1,

where ||⋅||1||⋅||1 denotes the trace norm, and TBTB stands for the partial transpose operation with respect to subsystem BB and can be defined as [7]

ρTBAB:=(I⊗T)(ρAB)=∑i,j(IA⊗|i⟩⟨j|B)ρAB(IA⊗|i⟩⟨j|B),(5)(5)ρABTB:=(I⊗T)(ρAB)=∑i,j(IA⊗|i⟩⟨j|B)ρAB(IA⊗|i⟩⟨j|B),

where {|i⟩B}{|i⟩B} is a basis of subsystem BB. It is easy to connect these two metrics as EN(ρ)=log2(2N(ρ)+1)EN(ρ)=log2(2N(ρ)+1). They are all related to the PPT criterion for separability.

A density matrix has a positive partial transpose (PPT) if its partial transposition has no negative eigenvalues (i.e. positive semidefinite). Otherwise, it's called NPT.

The reason why we introduce such metrics and criterion is not only helping us better understand quantum entanglement but also guiding us in distillation protocols. Note: All PPT states are NOT distillable. This means we can not use many copies of the same PPT states to reach a state closer to the maximally entangled state through LOCC in the asymptotic regime. So, it is always a good idea to check the PPT condition before we put the initial state into distillation protocols. For a detailed discussion on the relation between the positive map theory and separability, please refer to this review paper [8]. All these concepts are coded in Paddle Quantum by calling the functions negativity(),logarithmic_negativity(), and partial_transpose().

After introducing many new concepts, we provide a concrete example. For the specific Bell state |Φ+⟩AB|Φ+⟩AB, we have

ρTB=12(|00⟩⟨00|+|01⟩⟨10|+|10⟩⟨01|+|11⟩⟨11|),=12⎡⎢ ⎢ ⎢⎣1000001001000001⎤⎥ ⎥ ⎥⎦(6)ρTB=12(|00⟩⟨00|+|01⟩⟨10|+|10⟩⟨01|+|11⟩⟨11|),(6)=12[1000001001000001]

with a negative eigenvalue λ−(ρTB)=−1/2λ−(ρTB)=−1/2 and logarithmic negativity EN(ρ)=1EN(ρ)=1.

In [2]:
from paddle_quantum.qinfo import negativity, logarithmic_negativity, partial_transpose, is_ppt

input_state = bell_state(2)
transposed_state = partial_transpose(input_state, 1)   # 1 stands for the qubit number of system A
print("The transposed state is\n", transposed_state.numpy())

neg = negativity(input_state)
log_neg = logarithmic_negativity(input_state)
print("With negativity =", neg.numpy()[0], "and logarithmic_negativity =", log_neg.numpy()[0])
print("The input state satisfies the PPT condition and hence not distillable?", is_ppt(input_state))

The transposed state is
 [[0.5+0.j 0. +0.j 0. +0.j 0. +0.j]
 [0. +0.j 0. +0.j 0.5+0.j 0. +0.j]
 [0. +0.j 0.5+0.j 0. +0.j 0. +0.j]
 [0. +0.j 0. +0.j 0. +0.j 0.5+0.j]]
With negativity = 0.5 and logarithmic_negativity = 1.0
The input state satisfies the PPT condition and hence not distillable? False

In the context of entanglement distillation, we usually use the state fidelity FF between the distilled state ρoutρout and the Bell state |Φ+⟩|Φ+⟩ to quantify the performance of a distillation protocol, where

F(ρout,Φ+)≡⟨Φ+|ρout|Φ+⟩.(7)(7)F(ρout,Φ+)≡⟨Φ+|ρout|Φ+⟩.

Recall the target state in distillation task is |Φ+⟩|Φ+⟩. It is natural to choose state fidelity as the metric to quantify the distance between the current state and the target state. To calculate state fidelity, we can call the function state_fidelity(rho, sigma).

Fs(ρ,σ)≡tr(√√ρσ√ρ).(8)(8)Fs(ρ,σ)≡tr(ρσρ).

Notice they are differed by a square root F=F2sF=Fs2.

In [3]:
from paddle_quantum.state import isotropic_state
from paddle_quantum.qinfo import state_fidelity

F = state_fidelity(bell_state(2), isotropic_state(2, 0.7))
print("The state fidelity between these two states are:\nF=", (F**2).numpy()[0])

The state fidelity between these two states are:
F= 0.77500015

With many preparations, we can finally discuss the famous BBPSSW protocol in the next section.

BBPSSW protocol¶

The BBPSSW protocol distills two identical quantum states ρinρin (2-copies) into a single final state ρoutρout with a higher state fidelity FF (closer to the Bell state |Φ+⟩|Φ+⟩). It is worth noting that BBPSSW was mainly designed to purify isotropic states (also known as Werner state), a parametrized family of mixed states consist of |Φ+⟩|Φ+⟩ and the completely mixed state (white noise) I/4I/4.

ρiso(p)=p|Φ+⟩⟨Φ+|+(1−p)I4,p∈[0,1](9)(9)ρiso(p)=p|Φ+⟩⟨Φ+|+(1−p)I4,p∈[0,1]

This state is PPT and hence not distillable when p≤1/3p≤1/3.

We have two remote parties, AA (Alice) and BB (Bob), involved in the BBPSSW distillation protocol. They share two qubit pairs ρA0B0ρA0B0 and ρA1B1ρA1B1. Each pair is initialized as ρin=ρiso(p)ρin=ρiso(p). These states could come from last distillation process or previously distributed and stored in some memory registers of a quantum network. Alice holds two qubits A0,A1A0,A1, and Bob also holds two qubits B0,B1B0,B1. With these initial setups, Alice and Bob implement the following LOCC process:

  1. Alice and Bob firstly choose the qubit pair they want to keep as the memory qubit pair to store entanglement resource after distillation. Here, they choose A0A0 and B0B0.
  2. Alice and Bob both apply a CNOT gate on their qubits. Here, they choose A0,B0A0,B0 as the control qubits and A1,B1A1,B1 as the target qubits.
  3. Two remote parties measure the target qubits then use classical communication channel to exchange their measurement results mA1,mB1mA1,mB1.
  4. If the measurement results of Alice and Bob are the same (00 or 11), the distillation is successful, and the qubit pair A0,B0A0,B0 is stored as state ρoutρout; if the measurement results are different (01 or 10), they claim the distillation failed and the qubit pair A0,B0A0,B0 will be discarded.
No description has been provided for this image
Figure 1: Schematic diagram of the BBPSSW protocol

Note: The distillation protocol is probabilistic and it does not succeed every time. So, another metric to quantify the performance of distillation protocol is the probability of success psuccpsucc. In general, there exists a trade off between the final state fidelity F′=F(ρout,Φ+)F′=F(ρout,Φ+) and psuccpsucc. Theoretically, these two specific metrics for the BBPSSW protocol are provided as,

F′=F2+19(1−F)2F2+23F(1−F)+59(1−F)2,(10)(10)F′=F2+19(1−F)2F2+23F(1−F)+59(1−F)2,

where the initial fidelity F(ρin,Φ+)=(1+3p)/4F(ρin,Φ+)=(1+3p)/4 with a probability of success,

psucc =F2+23F(1−F)+59(1−F)2.(11)(11)psucc =F2+23F(1−F)+59(1−F)2.

In the next section, we will go through how to simulate the BBPSSW protocol with Paddle Quantum.

Note: If the input state is not an isotropic state, one can depolarize it to an isotropic state with a twirling operation.

Simulation with Paddle Quantum¶

First, we need to import all the dependencies:

In [4]:
import numpy as np
from paddle_quantum.locc import LoccNet
import paddle
from paddle import matmul, trace
from paddle_quantum.state import bell_state, isotropic_state
from paddle_quantum.qinfo import logarithmic_negativity, is_ppt

For convenience, we introduce the metrics of BBPSSW here and later compare with the simulation result.

In [5]:
def BBPSSW_metrics(p):
    """
    Returns output fidelity and probability of success of the BBPSSW protocol.
    """
    F_in = (1+3*p)/4
    p_succ = F_in**2 + 2*F_in*(1-F_in)/3+ 5*(1-F_in)**2/9
    F_out = (F_in**2 + (1-F_in)**2/9)/p_succ
 
    return F_in, F_out, p_succ

In our example, the input state is an isotropic state with p=0.7p=0.7, that is

ρin=ρiso(0.7)=0.7|Φ+⟩⟨Φ+|+0.075I.(12)(12)ρin=ρiso(0.7)=0.7|Φ+⟩⟨Φ+|+0.075I.
In [6]:
p = 0.7
F_in, F_out, p_succ = BBPSSW_metrics(p)
print("The input fidelity is:", F_in)
print("The output fidelity is:", F_out)
print("With a probability of success:", p_succ)
print("The input state satisfies the PPT condition and hence not distillable?", is_ppt(isotropic_state(2, p)))

The input fidelity is: 0.7749999999999999
The output fidelity is: 0.8137583892617447
With a probability of success: 0.745
The input state satisfies the PPT condition and hence not distillable? False

Then we can simulate the BBPSSW protocol and check if the results match with theory.

In [7]:
class LOCC(LoccNet):
    def __init__(self):
        super(LOCC, self).__init__()
        # Add the first party Alice 
        # The first parameter 2 stands for how many qubits A holds
        # The second parameter records the name of this party
        self.add_new_party(2, party_name='Alice')
        # Add the second party Bob
        # The first parameter 2 stands for how many qubits B holds
        # The second parameter records the name of this party
        self.add_new_party(2, party_name='Bob')

        # Define the input quantum states rho_in
        _state = isotropic_state(2, p)
        # ('Alice', 0) means Alice's first qubit A0
        # ('Bob', 0) means Bob's first qubit B0
        self.set_init_state(_state, [('Alice', 0), ('Bob', 0)])
        # ('Alice', 1) means Alice's second qubit A1
        # ('Bob', 1) means Bob's second qubit B1
        self.set_init_state(_state, [('Alice', 1), ('Bob', 1)])

        # Create Alice's local operations 
        self.cir1 = self.create_ansatz('Alice')
        self.cir1.cnot([0, 1])
        # Create Bob's local operations 
        self.cir2 = self.create_ansatz('Bob')
        self.cir2.cnot([0, 1])

    def BBPSSW(self):
        status = self.init_status
        # Run circuit
        status = self.cir1(status)
        status_mid = self.cir2(status)

        # ('Alice', 1) means measuring Alice's second qubit A1
        # ('Bob', 1) means measuring Bob's second qubit B1
        # ['00','11'] specifies the success condition for distillation
        # Means Alice and Bob both measure '00' or '11'
        status_mid = self.measure(status_mid, [('Alice', 1), ('Bob', 1)], ["00", "11"])

        # Trace out the measured qubits A1&B1
        # Leaving only Alice’s first qubit and Bob’s first qubit A0&B0 as the memory register
        status_fin = self.partial_state(status_mid, [('Alice', 0), ('Bob', 0)])

        return status_fin
In [9]:
# Run BBPSSW protocol
status_fin = LOCC().BBPSSW()

# Calculate fidelity
target_state = bell_state(2)
fidelity = 0
for status in status_fin:
    fidelity += paddle.real(trace(matmul(target_state.data, status.data)))
fidelity /= len(status_fin)

# Calculate success rate
suc_rate = sum([status.prob for status in status_fin])
fidelity_in, _, _ = BBPSSW_metrics(p)

# Output simulation results
print(f"The fidelity of the input quantum state is: {fidelity_in:.5f}")
print(f"The fidelity of the purified quantum state is: {fidelity.numpy()[0]:.5f}")
print(f"The probability of successful purification is: {suc_rate.numpy()[0]:#.3%}")

# Print the output state
rho_out = status_fin[0]
print("========================================================")
print(f"The output state is:\n {rho_out.data.numpy()}")
print(f"The initial logarithmic negativity is: {logarithmic_negativity(isotropic_state(2,p)).numpy()[0]}")
print(f"The final logarithmic negativity is: {logarithmic_negativity(rho_out).numpy()[0]}")

The fidelity of the input quantum state is: 0.77500
The fidelity of the purified quantum state is: 0.81376
The probability of successful purification is: 74.500%
========================================================
The output state is:
 [[0.48489934+0.j 0.        +0.j 0.        +0.j 0.32885906+0.j]
 [0.        +0.j 0.01510067+0.j 0.        +0.j 0.        +0.j]
 [0.        +0.j 0.        +0.j 0.01510067+0.j 0.        +0.j]
 [0.32885906+0.j 0.        +0.j 0.        +0.j 0.48489934+0.j]]
The initial logarithmic negativity is: 0.6322681307792664
The final logarithmic negativity is: 0.7026724219322205

Conclusion¶

As we can see, the simulation results matches the theoretical prediction perfectly. Through the BBPSSW protocol, we can extract an entangled state with a higher fidelity from two entangled states with low fidelities.

Advantages

  • Operations are simple. Only CNOT gates are required.
  • High success rate.

Disadvantages

  • Strict requirements for the input state type. Isotropic states are preferred.
  • Poor scalability. Unable to directly extend to the case of multiple copies.

We suggest interested readers to check the tutorial on how to design a new distillation protocol with LOCCNet.

References¶

[1] Chitambar, Eric, et al. "Everything you always wanted to know about LOCC (but were afraid to ask)." Communications in Mathematical Physics 328.1 (2014): 303-326.

[2] Bennett, Charles H., et al. "Purification of noisy entanglement and faithful teleportation via noisy channels." Physical Review Letters 76.5 (1996): 722.

[3] Bennett, Charles H., et al. "Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels." Physical Review Letters 70.13 (1993): 1895.

[4] Bennett, Charles H., and Stephen J. Wiesner. "Communication via one-and two-particle operators on Einstein-Podolsky-Rosen states." Physical Review Letters 69.20 (1992): 2881.

[5] Ekert, Artur K. "Quantum cryptography based on Bell’s theorem." Physical Review Letters 67.6 (1991): 661.

[6] Życzkowski, Karol, et al. "Volume of the set of separable states." Physical Review A 58.2 (1998): 883.

[7] Peres, Asher. "Separability criterion for density matrices." Physical Review Letters 77.8 (1996): 1413.

[8] Gühne, Otfried, and Géza Tóth. "Entanglement detection." Physics Reports 474.1-6 (2009): 1-75.