Python QuantumProgram.create_classical_register方法代码示例

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
 def test_create_several_circuits_noname(self):
     """Test create_circuit with several inputs and without names.
     """
     q_program = QuantumProgram()
     qr1 = q_program.create_quantum_register(size=3)
     cr1 = q_program.create_classical_register(size=3)
     qr2 = q_program.create_quantum_register(size=3)
     cr2 = q_program.create_classical_register(size=3)
     qc1 = q_program.create_circuit(qregisters=[qr1], cregisters=[cr1])
     qc2 = q_program.create_circuit(qregisters=[qr2], cregisters=[cr2])
     qc3 = q_program.create_circuit(qregisters=[qr1, qr2], cregisters=[cr1, cr2])
     self.assertIsInstance(qc1, QuantumCircuit)
     self.assertIsInstance(qc2, QuantumCircuit)
     self.assertIsInstance(qc3, QuantumCircuit)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [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 create_classical_register [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 create_classical_register [as 别名]
    def test_compile_coupling_map(self):
        """Test compile_coupling_map.

        If all correct should return data with the same stats. The circuit may
        be different.
        """
        QP_program = QuantumProgram()
        q = QP_program.create_quantum_register("q", 3, verbose=False)
        c = QP_program.create_classical_register("c", 3, verbose=False)
        qc = QP_program.create_circuit("circuitName", [q], [c])
        qc.h(q[0])
        qc.cx(q[0], q[1])
        qc.cx(q[0], q[2])
        qc.measure(q[0], c[0])
        qc.measure(q[1], c[1])
        qc.measure(q[2], c[2])
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 1024  # the number of shots in the experiment.
        coupling_map = {0: [1], 1: [2]}
        initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1),
                          ("q", 2): ("q", 2)}
        circuits = ["circuitName"]
        qobj = QP_program.compile(circuits, backend=backend, shots=shots,
                                  coupling_map=coupling_map,
                                  initial_layout=initial_layout, seed=88)
        result = QP_program.run(qobj)
        to_check = QP_program.get_qasm("circuitName")
        self.assertEqual(len(to_check), 160)
        self.assertEqual(result.get_counts("circuitName"),
                         {'000': 518, '111': 506})

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

        If all correct the qasm output for each circuit should be of a certain
        lenght

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 3, verbose=False)
        cr = QP_program.create_classical_register("cr", 3, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [qr], [cr])
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc1.h(qr[0])
        qc1.cx(qr[0], qr[1])
        qc1.cx(qr[1], qr[2])
        qc1.measure(qr[0], cr[0])
        qc1.measure(qr[1], cr[1])
        qc1.measure(qr[2], cr[2])
        qc2.h(qr)
        qc2.measure(qr[0], cr[0])
        qc2.measure(qr[1], cr[1])
        qc2.measure(qr[2], cr[2])
        result = QP_program.get_qasms(["qc1", "qc2"])
        self.assertEqual(len(result[0]), 173)
        self.assertEqual(len(result[1]), 159)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
    def test_teleport(self):
        """test teleportation as in tutorials"""

        self.log.info('test_teleport')
        pi = np.pi
        shots = 1000
        qp = QuantumProgram()
        qr = qp.create_quantum_register('qr', 3)
        cr0 = qp.create_classical_register('cr0', 1)
        cr1 = qp.create_classical_register('cr1', 1)
        cr2 = qp.create_classical_register('cr2', 1)
        circuit = qp.create_circuit('teleport', [qr],
                                    [cr0, cr1, cr2])
        circuit.h(qr[1])
        circuit.cx(qr[1], qr[2])
        circuit.ry(pi/4, qr[0])
        circuit.cx(qr[0], qr[1])
        circuit.h(qr[0])
        circuit.barrier(qr)
        circuit.measure(qr[0], cr0[0])
        circuit.measure(qr[1], cr1[0])
        circuit.z(qr[2]).c_if(cr0, 1)
        circuit.x(qr[2]).c_if(cr1, 1)
        circuit.measure(qr[2], cr2[0])
        backend = 'local_qasm_simulator'
        qobj = qp.compile('teleport', backend=backend, shots=shots,
                   seed=self.seed)
        results = qp.run(qobj)
        data = results.get_counts('teleport')
        alice = {}
        bob = {}
        alice['00'] = data['0 0 0'] + data['1 0 0']
        alice['01'] = data['0 1 0'] + data['1 1 0']
        alice['10'] = data['0 0 1'] + data['1 0 1']
        alice['11'] = data['0 1 1'] + data['1 1 1']
        bob['0'] = data['0 0 0'] + data['0 1 0'] +  data['0 0 1'] + data['0 1 1']
        bob['1'] = data['1 0 0'] + data['1 1 0'] +  data['1 0 1'] + data['1 1 1']
        self.log.info('test_telport: circuit:')
        self.log.info( circuit.qasm() )
        self.log.info('test_teleport: data {0}'.format(data))
        self.log.info('test_teleport: alice {0}'.format(alice))
        self.log.info('test_teleport: bob {0}'.format(bob))
        alice_ratio = 1/np.tan(pi/8)**2
        bob_ratio = bob['0']/float(bob['1'])
        error = abs(alice_ratio - bob_ratio) / alice_ratio
        self.log.info('test_teleport: relative error = {0:.4f}'.format(error))
        self.assertLess(error, 0.05)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
 def test_create_circuit_noname(self):
     """Test create_circuit with no name
     """
     q_program = QuantumProgram()
     qr = q_program.create_quantum_register(size=3)
     cr = q_program.create_classical_register(size=3)
     qc = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
     self.assertIsInstance(qc, QuantumCircuit)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
 def test_get_register_and_circuit_names_nonames(self):
     """Get the names of the circuits and registers after create them without a name
     """
     q_program = QuantumProgram()
     qr1 = q_program.create_quantum_register(size=3)
     cr1 = q_program.create_classical_register(size=3)
     qr2 = q_program.create_quantum_register(size=3)
     cr2 = q_program.create_classical_register(size=3)
     q_program.create_circuit(qregisters=[qr1], cregisters=[cr1])
     q_program.create_circuit(qregisters=[qr2], cregisters=[cr2])
     q_program.create_circuit(qregisters=[qr1, qr2], cregisters=[cr1, cr2])
     qrn = q_program.get_quantum_register_names()
     crn = q_program.get_classical_register_names()
     qcn = q_program.get_circuit_names()
     self.assertEqual(len(qrn), 2)
     self.assertEqual(len(crn), 2)
     self.assertEqual(len(qcn), 3)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
    def _get_quantum_program():
        quantum_program = QuantumProgram()
        qr = quantum_program.create_quantum_register("q", 1)
        cr = quantum_program.create_classical_register("c", 1)
        qc = quantum_program.create_circuit("qc", [qr], [cr])
        qc.h(qr[0])
        qc.measure(qr[0], cr[0])

        return quantum_program

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [as 别名]
def _test_circuits_2qubit():
    qp = QuantumProgram()
    qr = qp.create_quantum_register('qr', 2)
    cr = qp.create_classical_register('cr', 2)

    # Test Circuits Bell state
    circ = qp.create_circuit('Bell', [qr], [cr])
    circ.h(qr[0])
    circ.cx(qr[0], qr[1])
    circ = qp.create_circuit('X1Id0', [qr], [cr])
    circ.x(qr[1])
    return qp, qr, cr

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [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 create_classical_register [as 别名]
    def test_create_several_circuits(self):
        """Test create_circuit with several inputs.

        If all is correct we get a object intstance of QuantumCircuit

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
                from qiskit import QuantumCircuit
        """
        QP_program = QuantumProgram()
        qr1 = QP_program.create_quantum_register("qr1", 3, verbose=False)
        cr1 = QP_program.create_classical_register("cr1", 3, verbose=False)
        qr2 = QP_program.create_quantum_register("qr2", 3, verbose=False)
        cr2 = QP_program.create_classical_register("cr2", 3, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [qr1], [cr1])
        qc2 = QP_program.create_circuit("qc2", [qr2], [cr2])
        qc3 = QP_program.create_circuit("qc2", [qr1, qr2], [cr1, cr2])
        self.assertIsInstance(qc1, QuantumCircuit)
        self.assertIsInstance(qc2, QuantumCircuit)
        self.assertIsInstance(qc3, QuantumCircuit)

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

        If all is correct we get a object intstance of ClassicalRegister

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
                from qiskit import ClassicalRegister
        """
        QP_program = QuantumProgram()
        cr = QP_program.create_classical_register("cr", 3, verbose=False)
        self.assertIsInstance(cr, ClassicalRegister)

# 需要导入模块: from qiskit import QuantumProgram [as 别名]
# 或者: from qiskit.QuantumProgram import create_classical_register [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 create_classical_register [as 别名]
    def test_get_register_and_circuit_names(self):
        """Get the names of the circuits and registers.

        If all is correct we should get the arrays of the names

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
        """
        QP_program = QuantumProgram()
        qr1 = QP_program.create_quantum_register("qr1", 3, verbose=False)
        cr1 = QP_program.create_classical_register("cr1", 3, verbose=False)
        qr2 = QP_program.create_quantum_register("qr2", 3, verbose=False)
        cr2 = QP_program.create_classical_register("cr2", 3, verbose=False)
        QP_program.create_circuit("qc1", [qr1], [cr1])
        QP_program.create_circuit("qc2", [qr2], [cr2])
        QP_program.create_circuit("qc2", [qr1, qr2], [cr1, cr2])
        qrn = QP_program.get_quantum_register_names()
        crn = QP_program.get_classical_register_names()
        qcn = QP_program.get_circuit_names()
        self.assertEqual(qrn, {'qr1', 'qr2'})
        self.assertEqual(crn, {'cr1', 'cr2'})
        self.assertEqual(qcn, {'qc1', 'qc2'})