Python qiskit.ClassicalRegister方法代码示例

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def paddle_after_measurement(self, circuit, qubit_num, shot_num):
        self.update()
        self.display_statevector(qubit_num)

        backend_sv_sim = BasicAer.get_backend('qasm_simulator')
        cr = ClassicalRegister(qubit_num)
        measure_circuit = deepcopy(circuit)  # make a copy of circuit
        measure_circuit.add_register(cr)    # add classical registers for measurement readout
        measure_circuit.measure(measure_circuit.qregs[0], measure_circuit.cregs[0])
        job_sim = execute(measure_circuit, backend_sv_sim, shots=shot_num)
        result_sim = job_sim.result()
        counts = result_sim.get_counts(circuit)

        self.paddle.set_alpha(255)
        self.image.blit(self.paddle, (0, int(list(counts.keys())[0], 2) * self.block_size))

        return int(list(counts.keys())[0], 2) 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def quantum_fourier_transform_circuit(num_qubits):
    """Create quantum fourier transform circuit.

    Args:
        num_qubits (int): Number of qubits

    Returns:
        QuantumCircuit: QFT circuit
    """
    qreg = QuantumRegister(num_qubits)
    creg = ClassicalRegister(num_qubits)

    circuit = QuantumCircuit(qreg, creg, name="qft")

    n = len(qreg)

    for i in range(n):
        for j in range(i):
            circuit.cu1(math.pi/float(2**(i-j)), qreg[i], qreg[j])
        circuit.h(qreg[i])
    circuit.measure(qreg, creg)
    return circuit 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def test_amplitude_damping_error(self):
        """Test amplitude damping error damps to correct state"""
        qr = QuantumRegister(1, 'qr')
        cr = ClassicalRegister(1, 'cr')
        circuit = QuantumCircuit(qr, cr)
        circuit.x(qr)  # prepare + state
        for _ in range(30):
            # Add noisy identities
            circuit.barrier(qr)
            circuit.i(qr)
        circuit.barrier(qr)
        circuit.measure(qr, cr)
        shots = 4000
        backend = QasmSimulator()
        # test noise model
        error = amplitude_damping_error(0.75, 0.25)
        noise_model = NoiseModel()
        noise_model.add_all_qubit_quantum_error(error, 'id')
        # Execute
        target = {'0x0': 3 * shots / 4, '0x1': shots / 4}
        circuit = transpile(circuit, basis_gates=noise_model.basis_gates)
        qobj = assemble([circuit], backend, shots=shots)
        result = backend.run(qobj, noise_model=noise_model).result()
        self.assertSuccess(result)
        self.compare_counts(result, [circuit], [target], delta=0.05 * shots) 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def create_statevector_circuit(self):
        """ Creates a simple circuit for running in the statevector """
        qr = QuantumRegister(10)
        cr = ClassicalRegister(10)
        circuit = QuantumCircuit(qr, cr)
        circuit.u3(0.1, 0.1, 0.1, qr[0])
        circuit.barrier(qr)
        circuit.x(qr[0])
        circuit.barrier(qr)
        circuit.x(qr[1])
        circuit.barrier(qr)
        circuit.x(qr[0])
        circuit.barrier(qr)
        circuit.u3(0.1, 0.1, 0.1, qr[0])
        circuit.barrier(qr)
        circuit.measure(qr, cr)
        return circuit 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def create_circuit_for_truncate(self):
        qr = QuantumRegister(4)
        cr = ClassicalRegister(4)
        circuit = QuantumCircuit(qr, cr)
        circuit.u3(0.1,0.1,0.1,qr[1])
        circuit.barrier(qr)
        circuit.x(qr[2])
        circuit.barrier(qr)
        circuit.x(qr[1])
        circuit.barrier(qr)
        circuit.x(qr[3])
        circuit.barrier(qr)
        circuit.u3(0.1,0.1,0.1,qr[0])
        circuit.barrier(qr)
        circuit.measure(qr[0], cr[0])
        circuit.measure(qr[1], cr[1])
        return circuit 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def measure_circuits_nondeterministic(allow_sampling=True):
    """"Measure test circuits with non-deterministic count output."""

    circuits = []
    qr = QuantumRegister(2)
    cr = ClassicalRegister(2)

    # Measure |++> state (sampled)
    circuit = QuantumCircuit(qr, cr)
    circuit.h(qr)
    circuit.barrier(qr)
    circuit.measure(qr, cr)
    if not allow_sampling:
        circuit.barrier(qr)
        circuit.i(qr)
    circuits.append(circuit)

    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def pauli_measure_error_circuits():
    """Local Pauli measure error noise model circuits"""
    circuits = []

    qr = QuantumRegister(2, 'qr')
    cr = ClassicalRegister(2, 'cr')

    # 25% all-qubit Pauli error on measure
    circuit = QuantumCircuit(qr, cr)
    circuit.measure(qr, cr)
    circuits.append(circuit)

    # 25% local Pauli error on measure of qubit 1
    circuit = QuantumCircuit(qr, cr)
    circuit.measure(qr, cr)
    circuits.append(circuit)

    # 25 % non-local Pauli error on qubit 1 for measure of qubit-1
    circuit = QuantumCircuit(qr, cr)
    circuit.measure(qr, cr)
    circuits.append(circuit)

    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def h_gate_circuits_deterministic(final_measure=True):
    """H-gate test circuits with deterministic counts."""
    circuits = []
    qr = QuantumRegister(1)
    if final_measure:
        cr = ClassicalRegister(1)
        regs = (qr, cr)
    else:
        regs = (qr, )
    # HH=I
    circuit = QuantumCircuit(*regs)
    circuit.h(qr)
    circuit.barrier(qr)
    circuit.h(qr)
    if final_measure:
        circuit.barrier(qr)
        circuit.measure(qr, cr)
    circuits.append(circuit)
    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def h_gate_circuits_nondeterministic(final_measure=True):
    """X-gate test circuits with non-deterministic counts."""
    circuits = []
    qr = QuantumRegister(1)
    if final_measure:
        cr = ClassicalRegister(1)
        regs = (qr, cr)
    else:
        regs = (qr, )
    # H
    circuit = QuantumCircuit(*regs)
    circuit.h(qr)
    if final_measure:
        circuit.barrier(qr)
        circuit.measure(qr, cr)
    circuits.append(circuit)
    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def kraus_gate_error_circuits():
    """Kraus gate error noise model circuits"""
    circuits = []

    # Repeated amplitude damping to diagonal state
    qr = QuantumRegister(1, 'qr')
    cr = ClassicalRegister(1, 'cr')
    circuit = QuantumCircuit(qr, cr)
    circuit.x(qr)  # prepare + state
    for _ in range(30):
        # Add noisy identities
        circuit.barrier(qr)
        circuit.i(qr)
    circuit.barrier(qr)
    circuit.measure(qr, cr)
    circuits.append(circuit)

    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def unitary_random_gate_circuits_nondeterministic(final_measure=True):
    """Unitary gate test circuits with random unitary gate and nondeterministic count output."""
    # random_unitary seed = nq
    circuits = []
    for n in range(1, 5):
        qr = QuantumRegister(n, 'qr')
        if final_measure:
            cr = ClassicalRegister(n, 'cr')
            regs = (qr, cr)
        else:
            regs = (qr, )

        circuit = QuantumCircuit(*regs)
        circuit.unitary(random_unitary(2 ** n, seed=n), list(range(n)))
        if final_measure:
            circuit.barrier(qr)
            circuit.measure(qr, cr)
        circuits.append(circuit)

    return circuits 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def test_change_qobj_after_compile(self):
        """Test modifying Qobj parameters after compile."""
        qr = QuantumRegister(3)
        cr = ClassicalRegister(3)
        qc1 = QuantumCircuit(qr, cr)
        qc2 = QuantumCircuit(qr, cr)
        qc1.h(qr[0])
        qc1.cx(qr[0], qr[1])
        qc1.cx(qr[0], qr[2])
        qc2.h(qr)
        qc1.measure(qr, cr)
        qc2.measure(qr, cr)
        circuits = [qc1, qc2]
        qobj1 = assemble(circuits, shots=1024, seed=88)
        qobj1.experiments[0].config.shots = 50
        qobj1.experiments[1].config.shots = 1
        self.assertTrue(qobj1.experiments[0].config.shots == 50)
        self.assertTrue(qobj1.experiments[1].config.shots == 1)
        self.assertTrue(qobj1.config.shots == 1024) 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def test_text_measure_cregbundle(self):
        """ The measure operator, using 3-bit-length registers with cregbundle=True. """
        expected = '\n'.join(["        ┌─┐      ",
                              "q_0: |0>┤M├──────",
                              "        └╥┘┌─┐   ",
                              "q_1: |0>─╫─┤M├───",
                              "         ║ └╥┘┌─┐",
                              "q_2: |0>─╫──╫─┤M├",
                              "         ║  ║ └╥┘",
                              " c: 0 3/═╩══╩══╩═",
                              "         0  1  2 "])

        qr = QuantumRegister(3, 'q')
        cr = ClassicalRegister(3, 'c')
        circuit = QuantumCircuit(qr, cr)
        circuit.measure(qr, cr)
        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected) 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def test_text_measure_cregbundle_2(self):
        """ The measure operator, using 2 classical registers with cregbundle=True. """
        expected = '\n'.join(["        ┌─┐   ",
                              "q_0: |0>┤M├───",
                              "        └╥┘┌─┐",
                              "q_1: |0>─╫─┤M├",
                              "         ║ └╥┘",
                              "cA: 0 1/═╩══╬═",
                              "         0  ║ ",
                              "cB: 0 1/════╩═",
                              "            0 "])

        qr = QuantumRegister(2, 'q')
        cr_a = ClassicalRegister(1, 'cA')
        cr_b = ClassicalRegister(1, 'cB')
        circuit = QuantumCircuit(qr, cr_a, cr_b)
        circuit.measure(qr[0], cr_a[0])
        circuit.measure(qr[1], cr_b[0])
        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected) 

# 需要导入模块: import qiskit [as 别名]
# 或者: from qiskit import ClassicalRegister [as 别名]
def test_text_measure_1_reverse_bits(self):
        """ The measure operator, using 3-bit-length registers, with reverse_bits """
        expected = '\n'.join(['              ┌─┐',
                              'q_2: |0>──────┤M├',
                              '           ┌─┐└╥┘',
                              'q_1: |0>───┤M├─╫─',
                              '        ┌─┐└╥┘ ║ ',
                              'q_0: |0>┤M├─╫──╫─',
                              '        └╥┘ ║  ║ ',
                              ' c_2: 0 ═╬══╬══╩═',
                              '         ║  ║    ',
                              ' c_1: 0 ═╬══╩════',
                              '         ║       ',
                              ' c_0: 0 ═╩═══════',
                              '                 '])

        qr = QuantumRegister(3, 'q')
        cr = ClassicalRegister(3, 'c')
        circuit = QuantumCircuit(qr, cr)
        circuit.measure(qr, cr)
        self.assertEqual(str(_text_circuit_drawer(circuit, reverse_bits=True)), expected)