Python QuantumProgram.execute方法代码示例

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_simple_execute(self):
        name = 'test_simple'
        seed = 42
        qp = QuantumProgram()
        qr = qp.create_quantum_register('qr', 2)
        cr = qp.create_classical_register('cr', 2)
        qc = qp.create_circuit(name, [qr], [cr])
        qc.u1(3.14, qr[0])
        qc.u2(3.14, 1.57, qr[0])
        qc.measure(qr, cr)

        rtrue = qp.execute(name, seed=seed, skip_translation=True)
        rfalse = qp.execute(name, seed=seed, skip_translation=False)
        self.assertEqual(rtrue.get_counts(), rfalse.get_counts())

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_local_qasm_simulator_one_shot(self):
        """Test sinlge shot of local simulator .

        If all correct should the quantum state.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qr = QP_program.get_quantum_register("qname")
        cr = QP_program.get_classical_register("cname")
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc3 = QP_program.create_circuit("qc3", [qr], [cr])
        qc2.h(qr[0])
        qc3.h(qr[0])
        qc3.cx(qr[0], qr[1])
        qc3.cx(qr[0], qr[2])
        circuits = ['qc2', 'qc3']
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 1  # the number of shots in the experiment.
        result = QP_program.execute(circuits, backend=backend, shots=shots,
                                    seed=9)
        quantum_state = np.array([0.70710678+0.j, 0.70710678+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j])
        norm = np.dot(np.conj(quantum_state),
                      result.get_data('qc2')['quantum_state'])
        self.assertAlmostEqual(norm, 1)
        quantum_state = np.array([0.70710678+0.j, 0+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.70710678+0.j])
        norm = np.dot(np.conj(quantum_state),
                      result.get_data('qc3')['quantum_state'])
        self.assertAlmostEqual(norm, 1)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_average_data(self):
        """Test average_data.

        If all correct should the data.
        """
        QP_program = QuantumProgram()
        q = QP_program.create_quantum_register("q", 2, verbose=False)
        c = QP_program.create_classical_register("c", 2, verbose=False)
        qc = QP_program.create_circuit("qc", [q], [c])
        qc.h(q[0])
        qc.cx(q[0], q[1])
        qc.measure(q[0], c[0])
        qc.measure(q[1], c[1])
        circuits = ['qc']
        shots = 10000  # the number of shots in the experiment.
        backend = 'local_qasm_simulator'
        results = QP_program.execute(circuits, backend=backend, shots=shots)
        observable = {"00": 1, "11": 1, "01": -1, "10": -1}
        meanzz = results.average_data("qc", observable)
        observable = {"00": 1, "11": -1, "01": 1, "10": -1}
        meanzi = results.average_data("qc", observable)
        observable = {"00": 1, "11": -1, "01": -1, "10": 1}
        meaniz = results.average_data("qc", observable)
        self.assertAlmostEqual(meanzz,  1, places=1)
        self.assertAlmostEqual(meanzi,  0, places=1)
        self.assertAlmostEqual(meaniz,  0, places=1)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_local_qasm_simulator(self):
        """Test execute.

        If all correct should the data.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qr = QP_program.get_quantum_register("qname")
        cr = QP_program.get_classical_register("cname")
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc3 = QP_program.create_circuit("qc3", [qr], [cr])
        qc2.h(qr[0])
        qc2.cx(qr[0], qr[1])
        qc2.cx(qr[0], qr[2])
        qc3.h(qr)
        qc2.measure(qr[0], cr[0])
        qc3.measure(qr[0], cr[0])
        qc2.measure(qr[1], cr[1])
        qc3.measure(qr[1], cr[1])
        qc2.measure(qr[2], cr[2])
        qc3.measure(qr[2], cr[2])
        circuits = ['qc2', 'qc3']
        shots = 1024  # the number of shots in the experiment.
        backend = 'local_qasm_simulator'
        out = QP_program.execute(circuits, backend=backend, shots=shots,
                                 seed=88)
        results2 = out.get_counts('qc2')
        results3 = out.get_counts('qc3')
        # print(QP_program.get_data('qc3'))
        self.assertEqual(results2, {'000': 518, '111': 506})
        self.assertEqual(results3, {'001': 119, '111': 129, '110': 134,
                                    '100': 117, '000': 129, '101': 126,
                                    '010': 145, '011': 125})

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_local_unitary_simulator(self):
        """Test unitary simulator.

        If all correct should the h otimes h and cx.
        """
        QP_program = QuantumProgram()
        q = QP_program.create_quantum_register("q", 2, verbose=False)
        c = QP_program.create_classical_register("c", 2, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [q], [c])
        qc2 = QP_program.create_circuit("qc2", [q], [c])
        qc1.h(q)
        qc2.cx(q[0], q[1])
        circuits = ['qc1', 'qc2']
        backend = 'local_unitary_simulator'  # the backend to run on
        result = QP_program.execute(circuits, backend=backend)
        unitary1 = result.get_data('qc1')['unitary']
        unitary2 = result.get_data('qc2')['unitary']
        unitaryreal1 = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, -0.5, 0.5, -0.5],
                                 [0.5, 0.5, -0.5, -0.5],
                                 [0.5, -0.5, -0.5, 0.5]])
        unitaryreal2 = np.array([[1,  0,  0, 0], [0, 0,  0,  1],
                                 [0.,  0, 1, 0], [0,  1,  0,  0]])
        norm1 = np.trace(np.dot(np.transpose(np.conj(unitaryreal1)), unitary1))
        norm2 = np.trace(np.dot(np.transpose(np.conj(unitaryreal2)), unitary2))
        self.assertAlmostEqual(norm1, 4)
        self.assertAlmostEqual(norm2, 4)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
def use_sympy_backends():
    qprogram = QuantumProgram()
    current_dir = os.path.dirname(os.path.realpath(__file__))
    qasm_file = current_dir + "/../qasm/simple.qasm"
    qasm_circuit = qprogram.load_qasm_file(qasm_file)
    print("analyzing: " + qasm_file)
    print(qprogram.get_qasm(qasm_circuit))
    
    # sympy statevector simulator
    backend = 'local_statevector_simulator_sympy'
    result = qprogram.execute([qasm_circuit], backend=backend, shots=1, timeout=300)
    print("final quantum amplitude vector: ")
    print(result.get_data(qasm_circuit)['statevector'])

    # sympy unitary simulator
    backend = 'local_unitary_simulator_sympy'
    result = qprogram.execute([qasm_circuit], backend=backend, shots=1, timeout=300)
    print("\nunitary matrix of the circuit: ")
    print(result.get_data(qasm_circuit)['unitary'])

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
 def test_quantum_program_online(self):
     qp = QuantumProgram()
     qr = qp.create_quantum_register('qr', 2)
     cr = qp.create_classical_register('cr', 2)
     qc = qp.create_circuit('qc', [qr], [cr])
     qc.h(qr[0])
     qc.measure(qr[0], cr[0])
     backend = 'ibmqx_qasm_simulator'  # the backend to run on
     shots = 1024  # the number of shots in the experiment.
     qp.set_api(self.QE_TOKEN, self.QE_URL)
     result = qp.execute(['qc'], backend=backend, shots=shots,
                         seed=78)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
def state_tomography(state, n_qubits, shots):
    # cat target state: [1. 0. 0. ... 0. 0. 1.]/sqrt(2.)
    if state == 'cat':
        target = np.zeros(pow(2, n_qubits))
        target[0] = 1
        target[pow(2, n_qubits)-1] = 1.0
        target /= np.sqrt(2.0)
    # random target state: first column of a random unitary
    elif state == 'random':
        target = random_unitary_matrix(pow(2, n_qubits))[0]
    else:
        raise QISKitError("Unknown state for tomography.")

    print("target: {}".format(target))

    # Use the local qasm simulator
    backend = 'local_qasm_simulator'

    qp = QuantumProgram()

    # Prepared target state and assess quality
    qp = target_prep(qp, state, target)
    prep_result = qp.execute(['prep'], backend='local_statevector_simulator')
    prep_state = prep_result.get_data('prep')['statevector']
    F_prep = state_fidelity(prep_state, target)
    print('Prepared state fidelity =', F_prep)

    # Run state tomography simulation and fit data to reconstruct circuit
    qp, tomo_set, tomo_circuits = add_tomo_circuits(qp)
    tomo_result = qp.execute(tomo_circuits, backend=backend, shots=shots)
    tomo_data = tomo.tomography_data(tomo_result, 'prep', tomo_set)
    rho_fit = tomo.fit_tomography_data(tomo_data)

    # calculate fidelity and purity of fitted state
    F_fit = state_fidelity(rho_fit, target)
    pur = purity(rho_fit)
    print('Fitted state fidelity =', F_fit)
    print('Fitted state purity =', str(pur))

    return qp

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
 def test_execute_one_circuit_simulator_online(self):
     QP_program = QuantumProgram(specs=QPS_SPECS)
     qc = QP_program.get_circuit("circuitName")
     qr = QP_program.get_quantum_register("qname")
     cr = QP_program.get_classical_register("cname")
     qc.h(qr[1])
     qc.measure(qr[0], cr[0])
     shots = 1024  # the number of shots in the experiment.
     QP_program.set_api(API_TOKEN, URL)
     backend = QP_program.online_simulators()[0]
     # print(backend)
     result = QP_program.execute(['circuitName'], backend=backend,
                                 shots=shots, max_credits=3, silent=True)
     self.assertIsInstance(result, Result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
def simulate(grid):
    qp = QuantumProgram()

    qr = qp.create_quantum_register('qr', 2)
    cr = qp.create_classical_register('cr', 2)

    qc = qp.create_circuit('pi', [qr], [cr])

    qc = build_qc(qc, grid, qr, cr)
    result = qp.execute('pi')

    tmp = result.get_counts('pi')
    tmp = dict([(x[0], round(x[1] / 1024, 2)) for x in list(tmp.items())])

    return tmp

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
 def test_execute_several_circuits_simulator_online(self):
     QP_program = QuantumProgram(specs=QPS_SPECS)
     qr = QP_program.get_quantum_register("qname")
     cr = QP_program.get_classical_register("cname")
     qc2 = QP_program.create_circuit("qc2", [qr], [cr])
     qc3 = QP_program.create_circuit("qc3", [qr], [cr])
     qc2.h(qr[0])
     qc3.h(qr[0])
     qc2.measure(qr[0], cr[0])
     qc3.measure(qr[0], cr[0])
     circuits = ['qc2', 'qc3']
     shots = 1024  # the number of shots in the experiment.
     QP_program.set_api(API_TOKEN, URL)
     backend = QP_program.online_simulators()[0]
     result = QP_program.execute(circuits, backend=backend, shots=shots,
                                 max_credits=3, silent=True)
     self.assertIsInstance(result, Result)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_execute_program_map(self):
        """Test execute_program_map.

        If all correct should return 10010.
        """
        QP_program = QuantumProgram()
        QP_program.set_api(API_TOKEN, URL)
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 100  # the number of shots in the experiment.
        max_credits = 3
        coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]}
        initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1),
                          ("q", 2): ("q", 2), ("q", 3): ("q", 3),
                          ("q", 4): ("q", 4)}
        QP_program.load_qasm_file(QASM_FILE_PATH_2, "circuit-dev")
        circuits = ["circuit-dev"]
        result = QP_program.execute(circuits, backend=backend, shots=shots,
                                    max_credits=max_credits,
                                    coupling_map=coupling_map,
                                    initial_layout=initial_layout, seed=5455)
        self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
 def test_add_circuit_noname(self):
     """Test add two circuits without names. Also tests get_counts without circuit name.
     """
     q_program = QuantumProgram()
     qr = q_program.create_quantum_register(size=2)
     cr = q_program.create_classical_register(size=2)
     qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
     qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
     qc1.h(qr[0])
     qc1.measure(qr[0], cr[0])
     qc2.measure(qr[1], cr[1])
     new_circuit = qc1 + qc2
     q_program.add_circuit(quantum_circuit=new_circuit)
     backend = 'local_qasm_simulator_py'  # cpp simulator rejects non string IDs (FIXME)
     shots = 1024
     result = q_program.execute(backend=backend, shots=shots, seed=78)
     counts = result.get_counts(new_circuit.name)
     target = {'00': shots / 2, '01': shots / 2}
     threshold = 0.04 * shots
     self.assertDictAlmostEqual(counts, target, threshold)
     self.assertRaises(QISKitError, result.get_counts)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_combine_results(self):
        """Test run.

        If all correct should the data.
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 1)
        cr = QP_program.create_classical_register("cr", 1)
        qc1 = QP_program.create_circuit("qc1", [qr], [cr])
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc1.measure(qr[0], cr[0])
        qc2.x(qr[0])
        qc2.measure(qr[0], cr[0])
        shots = 1024  # the number of shots in the experiment.
        backend = 'local_qasm_simulator'
        res1 = QP_program.execute(['qc1'], backend=backend, shots=shots)
        res2 = QP_program.execute(['qc2'], backend=backend, shots=shots)
        counts1 = res1.get_counts('qc1')
        counts2 = res2.get_counts('qc2')
        res1 += res2 # combine results
        counts12 = [res1.get_counts('qc1'), res1.get_counts('qc2')]
        self.assertEqual(counts12, [counts1, counts2])

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import execute [as 别名]
    def test_execute_one_circuit_real_online(self):
        """Test execute_one_circuit_real_online.

        If all correct should return a result object
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 1, verbose=False)
        cr = QP_program.create_classical_register("cr", 1, verbose=False)
        qc = QP_program.create_circuit("circuitName", [qr], [cr])
        qc.h(qr)
        qc.measure(qr[0], cr[0])
        QP_program.set_api(API_TOKEN, URL)
        backend_list = QP_program.online_backends()
        if backend_list:
            backend = backend_list[0]
        shots = 1  # the number of shots in the experiment.
        status = QP_program.get_backend_status(backend)
        if status['available'] is False:
            pass
        else:
            result = QP_program.execute(['circuitName'], backend=backend,
                                        shots=shots, max_credits=3)
            self.assertIsInstance(result, Result)