• 如果测量结果为 ，则 Bob 的态将为 。
  无需任何操作即可完成传输。
• 如果测量结果为 ，则 Bob 的态将为 。
  Bob 需要在其量子比特上作用  门。
• 如果测量结果为 ，则 Bob 的态将为 。
  Bob 需要在其量子比特上作用  门。
• 如果测量结果为 ，则 Bob 的态将为 。
  Bob 需要在其量子比特上执行  门操作，然后执行  门操作。

   
     
    
      pip install paddle-quantum
   
     

   
     
    
      git clone http://github.com/PaddlePaddle/quantum
cd quantum
pip install -e .
   
     

   
     
    
      import numpy as np
from paddle_quantum.locc import LoccNet
from paddle import matmul, trace
import paddle
from paddle_quantum.utils import state_fidelity
from paddle_quantum.state import bell_state, isotropic_state, density_op_random
#初始化整个量子系统，然后定义量子电路和隐形传态协议。
class LOCC(LoccNet):
    def __init__(self):
        super(LOCC, self).__init__()

        # 添加第一个参与方 Alice
        # 第一个参数 2 代表着 Alice 手里有几个量子比特
        # 第二个参数代表着参与方的名字
        self.add_new_party(2, party_name="Alice")

        # 添加第二个参与方 Bob
        # 第一个参数 1 代表着 Bob 手里有几个量子比特
        # 第二个参数代表着参与方的名字
        self.add_new_party(1, party_name="Bob")


        # 准备一个贝尔态
        _state = paddle.to_tensor(bell_state(2))
        # _state = paddle.to_tensor(isotropic_state(2, 0.8))


        # 随机制备传输用的纯态 （rank =1）
        random_state = density_op_random(n=1, real_or_complex=2, rank=1)
        self.state_C = paddle.to_tensor(random_state)

        # 通过分配上述制备好的量子态初始化整个量子系统
        # 这里 ("Alice", 0) 即表示量子比特 C
        # 这里 ("Alice", 1) 即表示量子比特 A
        # 这里 ("Bob", 0) 即表示量子比特 B
        # print('提前分配好的纠缠态为:\n', _state.numpy())
        self.set_init_state(self.state_C, [("Alice", 0)])
        self.set_init_state(_state, [("Alice", 1), ("Bob", 0)])


    def teleportation(self):
        status = self.init_status

        # 设置 Alice 的本地操作
        cirA = self.create_ansatz("Alice")
        cirA.cnot([0, 1])
        cirA.h(0)

        # 运行上述电路
        status = cirA.run(status)

        # Alice 在计算基上测量她所持有的两个量子比特 C 还有 A
        # 得到并记录四种结果 00，01，10，11
        status_A = self.measure(status, [("Alice", 0), ("Alice", 1)], ["00", "01", "10", "11"])

        # 用于记录平均保真度
        fid_list = []

        # Bob 根据 Alice 的测量结果选择不同的门作用在自己的量子比特上
        for i, s in enumerate(status_A):

            # 判断语句根据 Alice 的测量结果，进行不同操作 
            if status_A[i].measured_result == '00':

                # 创建 Bob 的本地操作
                cirB = self.create_ansatz("Bob")

                # 执行电路
                status_B = cirB.run(s) 

                # 仅保留 Bob 的量子比特 B
                status_fin = self.partial_state(status_B, [("Bob", 0)])

                # 计算初始态和传输后态之间的保真度
                fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2
                fid_list.append(fid * status_fin.prob.numpy()[0])

            # 以下操作类似
            elif status_A[i].measured_result == '01':
                cirB = self.create_ansatz("Bob")
                cirB.x(0)
                status_B = cirB.run(s)
                status_fin = self.partial_state(status_B, [("Bob", 0)])
                fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2
                fid_list.append(fid * status_fin.prob.numpy()[0])
            elif status_A[i].measured_result == '10':
                cirB = self.create_ansatz("Bob")
                cirB.z(0)
                status_B = cirB.run(s)
                status_fin = self.partial_state(status_B, [("Bob", 0)])
                fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2
                fid_list.append(fid * status_fin.prob.numpy()[0])
            elif status_A[i].measured_result == '11':
                cirB = self.create_ansatz("Bob")
                cirB.x(0)
                cirB.z(0)
                status_B = cirB.run(s)
                status_fin = self.partial_state(status_B, [("Bob", 0)])
                fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2
                fid_list.append(fid * status_fin.prob.numpy()[0])
        fid_avg = sum(fid_list)
        return fid_avg
#然后，我们随机生成 200 个量子纯态，并使用态保真度来衡量传输协议好坏
SEED = 999              # 固定随机数
num_state = 200         # 设置随机态的生成数量
list_fid = []           # 用于记录保真度
np.random.seed(SEED)
# 开始采样 
for idx in range(num_state):
    list_fid.append(LOCC().teleportation())

print('平均保真度 =', np.around(sum(list_fid)/len(list_fid), 4), ', 标准差 =', np.std(list_fid))
   
     

• Alice 对她所持有的两个量子比特作用两量子比特通用门。
• 然后 Alice 在计算基上测量她的两个量子比特，并通过经典信道与 Bob 交流。
• 共计有 4 种可能的测量结果：‍ 。Bob 需要根据这些测量结果采取不同的本地操作。在 Bob 进行操作后，记其量子态为 。
• 计算 与 （纯态）之间的量子态重叠（state overlap）并记为O 。
  由于 LOCCNet 框架目前仅支持密度矩阵形式，因此我们必须将它们重写为 和 。然后可以得到 。对于纯态，此距离度量就是保真度 (fidelity)。
• 将损失函数设置为 4 种可能测量结果的累加，即 ，并使用基于梯度的优化方法更新 Alice 和 Bob 本地操作中的参数，从而使得损失函数最小化。
• 重复步骤 1-5，直到损失函数收敛。
• 生成一组随机的态 ，并以平均保真度对训练出的传输协议进行基准测试。