Пример #1
0
def test_layer1():
    init_machine = InitQMachine()
    machine = init_machine.m_machine
    q = machine.qAlloc_many(4)
    c = machine.cAlloc_many(4)
    prog = pq.QProg()
    cir = pq.QCircuit()
    cir.insert(pq.RX(q[1], np.pi / 5)).insert(pq.RX(q[1], np.pi / 5))
    cir.insert(pq.CU(1, 2, 3, 4, q[1], q[0])).insert(pq.H(q[1])).insert(
        pq.X(q[2])).insert(pq.RZ(q[1], np.pi / 2)).insert(pq.Y(q[2]))
    cir.insert(pq.CR(q[0], q[3], np.pi / 2)).insert(pq.S(q[2])).insert(
        pq.S(q[1])).insert(pq.RZ(q[1],
                                 np.pi / 2)).insert(pq.RZ(q[1], np.pi / 2))
    cir.insert(pq.RZ(q[1], np.pi / 2)).insert(pq.RZ(q[1], np.pi / 2)).insert(
        pq.Y(q[0])).insert(pq.SWAP(q[3], q[1]))
    cir.insert(pq.CU(1, 2, 3, 4, q[1], q[0])).insert(pq.H(q[1])).insert(
        pq.X(q[2])).insert(pq.RX(q[1], np.pi / 2)).insert(
            pq.RX(q[1], np.pi / 2)).insert(pq.Y(q[2]))
    cir.insert(pq.CR(q[2], q[3],
                     np.pi / 2)).insert(pq.CU(1, 2, 3, 4, q[1], q[0])).insert(
                         pq.H(q[1])).insert(pq.X(q[2])).insert(
                             pq.RZ(q[1], np.pi / 2)).insert(pq.Y(q[2]))

    cir2 = pq.QCircuit()
    cir2.insert(pq.H(q[1])).insert(pq.X(q[2])).insert(pq.X(q[2])).insert(
        pq.H(q[1])).insert(pq.X(q[3])).insert(pq.X(q[3]))

    cir3 = pq.QCircuit()
    cir3.insert(pq.H(q[1])).insert(pq.H(q[2])).insert(pq.CNOT(
        q[2], q[1])).insert(pq.H(q[1])).insert(pq.H(q[2]))

    theta_1 = np.pi / 3.0
    cir5 = pq.QCircuit()
    cir5.insert(pq.RZ(q[3], np.pi / 2.0)).insert(pq.CZ(q[3], q[0])).insert(
        pq.RX(q[3], np.pi / 2.0)).insert(pq.RZ(q[3], theta_1))
    cir5.insert(pq.RX(q[3], -np.pi / 2.0)).insert(pq.CZ(q[3], q[0])).insert(
        pq.RZ(q[3], -np.pi / 2.0))

    prog.insert(cir).insert(cir2).insert(pq.Reset(
        q[1])).insert(cir3).insert(cir5).insert(pq.measure_all(q, c))
    print("befort optimizered QProg:")
    print(prog)

    # 线路替换优化,会自动读配置文件,从配置文件加载线路替换信息
    #new_prog = pq.circuit_optimizer_by_config(prog)

    # 线路替换优化,mode参数用于优化类型,默认是Merge_H_X(合并抵消连续的H门和x门)
    #new_prog = pq.circuit_optimizer_by_config(prog, mode = pq.QCircuitOPtimizerMode.Merge_RX)

    # u3门转换
    new_prog = pq.circuit_optimizer(prog,
                                    mode_list=[
                                        pq.QCircuitOPtimizerMode.Merge_H_X,
                                        pq.QCircuitOPtimizerMode.Merge_U3
                                    ])

    print("The optimizered QProg:")
    print(new_prog)
Пример #2
0
def test_is_swappable(q, c):
    prog = pq.QProg()
    cir = pq.QCircuit()
    cir2 = pq.QCircuit()
    cir2.insert(pq.H(q[0])).insert(pq.RX(q[1], math.pi / 2)).insert(pq.T(
        q[2])).insert(pq.RY(q[3],
                            math.pi / 2)).insert(pq.RZ(q[2], math.pi / 2))
    cir.insert(pq.H(q[1])).insert(cir2).insert(pq.CR(q[1], q[2], math.pi / 2))
    prog.insert(pq.H(q[0])).insert(pq.S(q[2]))\
        .insert(cir)\
        .insert(pq.CNOT(q[0], q[1])).insert(pq.CZ(q[1], q[2])).insert(pq.measure_all(q,c))

    iter_first = cir2.begin()

    iter_second = iter_first.get_next()
    iter_second = iter_second.get_next()
    iter_second = iter_second.get_next()

    type = iter_first.get_node_type()
    if pq.NodeType.GATE_NODE == type:
        gate = pq.QGate(iter_first)
        print(gate.gate_type())

    type = iter_second.get_node_type()
    if pq.NodeType.GATE_NODE == type:
        gate = pq.QGate(iter_second)
        print(gate.gate_type())

    if (pq.is_swappable(prog, iter_first, iter_second)) == True:
        print('Could be swapped !\n')
    else:
        print('Could NOT be swapped.')
Пример #3
0
def test_layer1():
    init_machine = InitQMachine()
    machine = init_machine.m_machine
    q = machine.qAlloc_many(6)
    c = machine.cAlloc_many(6)
    prog = pq.QProg()
    cir = pq.QCircuit()
    cir.insert(pq.T(q[0])).insert(pq.iSWAP(q[1], q[5], 3.2233233)).insert(
        pq.S(q[1])).insert(pq.CNOT(q[1], q[0]))
    cir.insert(pq.CU(np.pi / 3, 3, 4, 5, q[1], q[2]))
    cir.insert(pq.CR(q[2], q[1], 0.00000334))
    cir.insert(pq.RX(q[2], np.pi / 3)).insert(pq.RZ(q[2], np.pi / 3)).insert(
        pq.RY(q[2], np.pi / 3))
    cir.insert(pq.CZ(q[0],
                     q[2])).insert(pq.CU(np.pi / 3, 3, 4, 5, q[5],
                                         q[2])).insert(pq.SWAP(q[1], q[0]))
    cir.set_control([q[4], q[3]])
    cir.set_dagger(True)
    prog.insert(cir)

    # 打印多控门分解之前的量子线路
    draw_qprog(prog,
               'pic',
               filename='D:/before_decompose_multiple_control_qgate.jpg',
               verbose=True)

    #多控门分解接口
    new_prog = pq.decompose_multiple_control_qgate(prog, machine)

    #打印多控门分解之后的量子线路
    draw_qprog(new_prog,
               'pic',
               filename='D:/after_decompose_multiple_control_qgate.jpg',
               verbose=True)
Пример #4
0
def test_get_matrix(q, c):
    prog = pq.QProg()
    prog.insert(pq.H(q[0])).insert(pq.S(q[2])).insert(pq.CNOT(
        q[0], q[1])).insert(pq.CZ(q[1],
                                  q[2])).insert(pq.CR(q[1], q[2], math.pi / 2))
    iter_start = prog.begin()
    iter_end = iter_start.get_next()
    iter_end = iter_end.get_next()
    result_mat = pq.get_matrix(prog, iter_start, iter_end)
    pq.print_mat(result_mat)
Пример #5
0
 def test_get_matrix(self):
     init_machine = InitQMachine(8, 8)
     q = init_machine.m_qlist
     c = init_machine.m_clist
     machine = init_machine.m_machine
     prog = pq.QProg()
     prog.insert(pq.H(q[0])).insert(pq.S(q[2])).insert(pq.CNOT(
         q[0],
         q[1])).insert(pq.CZ(q[1],
                             q[2])).insert(pq.CR(q[1], q[2], math.pi / 2))
     iter_start = prog.begin()
     iter_end = iter_start.get_next()
     iter_end = iter_end.get_next()
Пример #6
0
 def test_layer1(self):
     init_machine = InitQMachine()
     machine = init_machine.m_machine
     q = machine.qAlloc_many(6)
     c = machine.cAlloc_many(6)
     prog = pq.QProg()
     cir = pq.QCircuit()
     cir.insert(pq.T(q[0])).insert(pq.iSWAP(q[1], q[5], 3.2233233)).insert(pq.S(q[1])).insert(pq.CNOT(q[1], q[0]))
     cir.insert(pq.CU(np.pi/3, 3, 4, 5, q[1], q[2]))
     cir.insert(pq.CR(q[2], q[1], 0.00000334))
     cir.insert(pq.RX(q[2], np.pi/3)).insert(pq.RZ(q[2], np.pi/3)).insert(pq.RY(q[2], np.pi/3))
     cir.insert(pq.CZ(q[0], q[2])).insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2])).insert(pq.SWAP(q[1], q[0]))
     cir.set_control([q[4],q[3]])
     cir.set_dagger(True)
     prog.insert(cir)
Пример #7
0
def test_layer1():
    init_machine = InitQMachine()
    machine = init_machine.m_machine
    q = machine.qAlloc_many(6)
    c = machine.cAlloc_many(6)
    prog = pq.QProg()
    cir = pq.QCircuit()
    cir.insert(pq.T(q[0])).insert(pq.SWAP(q[1], q[5])).insert(pq.S(q[1])).insert(pq.CNOT(q[1], q[0]))
    cir.insert(pq.CZ(q[0], q[2])).insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2]))
    cir.set_control([q[4],q[3]])
    cir.set_dagger(True)
    
    prog.insert(pq.T(q[0])).insert(pq.SWAP(q[1], q[2])).insert(pq.X1(q[3]))
    prog.insert(pq.X(q[0])).insert(pq.CZ(q[1], q[2])).insert(pq.Y(q[3])).insert(pq.Z(q[3]))
    prog.insert(pq.S(q[3])).insert(pq.CNOT(q[1], q[4]))
    prog.insert(pq.CR(q[0], q[2], 2.3)).insert(pq.CR(q[0], q[1], np.pi/2.3)).insert(pq.Y1(q[4])).insert(pq.Z1(q[5]))
    prog.insert(pq.CR(q[5], q[2], np.pi/3))
    prog.insert(pq.CR(q[2], q[3], np.pi/5))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2]))
    prog.insert(pq.T(q[0])).insert(pq.SWAP(q[1], q[2])).insert(pq.X1(q[3]))
    prog.insert(pq.X(q[0])).insert(pq.CZ(q[1], q[2])).insert(pq.Y(q[3])).insert(pq.Z(q[3]))
    prog.insert(pq.S(q[3]))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[1]))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[3], q[2]))
    prog.insert(pq.CR(q[0], q[2], 2.3)).insert(pq.CR(q[0], q[1], np.pi/2.3)).insert(pq.Y1(q[4])).insert(pq.Z1(q[5]))
    prog.insert(pq.CR(q[5], q[2], np.pi/3))
    prog.insert(pq.CR(q[2], q[3], np.pi/5))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.CR(q[0], q[2], 2.3)).insert(pq.CR(q[0], q[1], np.pi/2.3)).insert(pq.Y1(q[4])).insert(pq.Z1(q[5]))
    prog.insert(pq.CR(q[5], q[2], np.pi/3))
    prog.insert(pq.CR(q[2], q[3], np.pi/5))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2]))
    prog.insert(pq.T(q[0])).insert(pq.SWAP(q[1], q[2])).insert(pq.X1(q[3]))
    prog.insert(pq.X(q[0])).insert(pq.CZ(q[1], q[2])).insert(pq.Y(q[3])).insert(pq.Z(q[3]))
    prog.insert(pq.S(q[3]))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[1]))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[3], q[2]))
    prog.insert(pq.S(q[3]))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[1]))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[3], q[2]))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2]))
    prog.insert(pq.T(q[0])).insert(pq.SWAP(q[1], q[2])).insert(pq.X1(q[3]))
    prog.insert(pq.X(q[0])).insert(pq.CZ(q[1], q[2])).insert(pq.Y(q[3])).insert(pq.Z(q[3]))
    prog.insert(pq.S(q[3]))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[1]))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[3], q[2]))
    prog.insert(pq.S(q[3]))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[5]))
    prog.insert(pq.CR(q[0], q[2], 2.3)).insert(pq.CR(q[0], q[1], np.pi/2.3)).insert(pq.Y1(q[4])).insert(pq.Z1(q[5]))
    prog.insert(pq.CR(q[5], q[2], np.pi/3))
    prog.insert(pq.CR(q[2], q[3], np.pi/5))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(cir)
    prog.insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[5]))
    prog.insert(pq.CR(q[0], q[2], 2.3)).insert(pq.CR(q[0], q[1], np.pi/2.3)).insert(pq.Y1(q[4])).insert(pq.Z1(q[5]))
    prog.insert(pq.CR(q[5], q[2], np.pi/3))
    prog.insert(pq.CR(q[2], q[3], np.pi/5))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[2], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[5], 1, np.pi/2)).insert(pq.U3(q[5], 1.2, 2, np.pi/3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.U4(1.5, 2.2, np.pi/3, np.pi/4, q[3]))
    prog.insert(pq.RX(q[2], np.pi/6.2)).insert(pq.RY(q[2], 6.6)).insert(pq.RZ(q[5], np.pi/3))
    prog.insert(pq.U1(q[0], np.pi/4)).insert(pq.U2(q[1], 1, np.pi/2)).insert(pq.U3(q[2], 1.2, 2, np.pi/3))
    prog.insert(pq.CU(np.pi/3, 3, 4, 5, q[5], q[2]))
    prog.insert(pq.H(q[0])).insert(pq.iSWAP(q[5], q[2], np.pi/2.3)).insert(pq.iSWAP(q[4], q[1]))
    prog.insert(pq.H(q[0])).insert(pq.H(q[1])).insert(pq.H(q[2])).insert(pq.H(q[3])).insert(pq.H(q[4])).insert(pq.H(q[5])).insert(pq.measure_all(q, c))
    prog.insert(pq.H(q[0])).insert(pq.H(q[1])).insert(pq.Measure(q[0], c[0]))
    
    print(prog)
    draw_circuit_pic(prog, 'D:/test_cir_my_draw.jpg', verbose=True)