def test_remove_clbits_without_register(self): """clbits of final measurements not in a register are removed.""" def expected_dag(): q0 = QuantumRegister(1, "q0") qc = QuantumCircuit(q0) return circuit_to_dag(qc) q0 = QuantumRegister(1, "q0") qc = QuantumCircuit(q0) # Add clbit without adding register qc.add_bits([Clbit()]) self.assertFalse(qc.cregs) # Measure to regless clbit qc.measure(0, 0) dag = circuit_to_dag(qc) dag = RemoveFinalMeasurements().run(dag) self.assertFalse(dag.cregs) self.assertFalse(dag.clbits) self.assertEqual(dag, expected_dag())
def test_multiple_register_from_bit(self, bit_type, reg_type): """Verify we find individual bits in multiple registers.""" bits = [bit_type() for _ in range(10)] even_reg = reg_type(bits=bits[::2]) odd_reg = reg_type(bits=bits[1::2]) fwd_reg = reg_type(bits=bits) rev_reg = reg_type(bits=bits[::-1]) qc = QuantumCircuit() qc.add_bits(bits) qc.add_register(even_reg, odd_reg, fwd_reg, rev_reg) for idx, bit in enumerate(bits): if idx % 2: self.assertEqual( qc.find_bit(bit), (idx, [(odd_reg, idx // 2), (fwd_reg, idx), (rev_reg, 9 - idx)]), ) else: self.assertEqual( qc.find_bit(bit), (idx, [(even_reg, idx // 2), (fwd_reg, idx), (rev_reg, 9 - idx)]), )
def test_standalone_and_shared_out_of_order(self): """Test circuit with register bits inserted out of order.""" qr_standalone = QuantumRegister(2, "standalone") qubits = [Qubit() for _ in range(5)] clbits = [Clbit() for _ in range(5)] qc = QuantumCircuit() qc.add_bits(qubits) qc.add_bits(clbits) random.shuffle(qubits) random.shuffle(clbits) qr = QuantumRegister(bits=qubits) cr = ClassicalRegister(bits=clbits) qc.add_register(qr) qc.add_register(cr) qr_standalone = QuantumRegister(2, "standalone") cr_standalone = ClassicalRegister(2, "classical_standalone") qc.add_bits([qr_standalone[1], qr_standalone[0]]) qc.add_bits([cr_standalone[1], cr_standalone[0]]) qc.add_register(qr_standalone) qc.add_register(cr_standalone) qc.unitary(random_unitary(32, seed=42), qr) qc.unitary(random_unitary(4, seed=100), qr_standalone) qc.measure(qr, cr) qc.measure(qr_standalone, cr_standalone) qpy_file = io.BytesIO() dump(qc, qpy_file) qpy_file.seek(0) new_circ = load(qpy_file)[0] self.assertEqual(qc, new_circ)
def test_registerless_add_bits(self, bit_type): """Verify we find individual bits added via QuantumCircuit.add_bits.""" bits = [bit_type() for _ in range(5)] qc = QuantumCircuit() qc.add_bits(bits) for idx, bit in enumerate(bits): self.assertEqual(qc.find_bit(bit), (idx, []))
def test_inserted_ancilla_bits_are_added_to_qubits(self): """Verify AncillaQubits added via .add_bits are added to .qubits.""" anc = AncillaQubit() qb = Qubit() qc = QuantumCircuit() qc.add_bits([anc, qb]) self.assertEqual(qc.qubits, [anc, qb])
def test_addding_individual_bit(self): """Verify we can add a single bit to a circuit.""" qr = QuantumRegister(3, "qr") qc = QuantumCircuit(qr) new_bit = Qubit() qc.add_bits([new_bit]) self.assertEqual(qc.qubits, list(qr) + [new_bit]) self.assertEqual(qc.qregs, [qr])
def test_overlapped_add_bits_and_add_register(self): """Test add registers whose bits have already been added by add_bits.""" qc = QuantumCircuit() for bit_type, reg_type in ( [Qubit, QuantumRegister], [Clbit, ClassicalRegister], [AncillaQubit, AncillaRegister], ): bits = [bit_type() for _ in range(10)] reg = reg_type(bits=bits) qc.add_bits(bits) qc.add_register(reg) self.assertEqual(qc.num_qubits, 20) self.assertEqual(qc.num_clbits, 10) self.assertEqual(qc.num_ancillas, 10)
def test_raise_if_bits_already_present(self): """Verify we raise when attempting to add a Bit already in the circuit.""" qubits = [Qubit()] with self.assertRaisesRegex(CircuitError, "bits found already"): _ = QuantumCircuit(qubits, qubits) qc = QuantumCircuit(qubits) with self.assertRaisesRegex(CircuitError, "bits found already"): qc.add_bits(qubits) qr = QuantumRegister(1, "qr") qc = QuantumCircuit(qr) with self.assertRaisesRegex(CircuitError, "bits found already"): qc.add_bits(qr[:])
def test_shared_bit_register(self): """Test a circuit with shared bit registers.""" qubits = [Qubit() for _ in range(5)] qc = QuantumCircuit() qc.add_bits(qubits) qr = QuantumRegister(bits=qubits) qc.add_register(qr) qc.h(qr) qc.cx(0, 1) qc.cx(0, 2) qc.cx(0, 3) qc.cx(0, 4) qc.measure_all() qpy_file = io.BytesIO() dump(qc, qpy_file) qpy_file.seek(0) new_qc = load(qpy_file)[0] self.assertEqual(qc, new_qc)
def test_mixed_registers(self): """Test circuit with mix of standalone and shared registers.""" qubits = [Qubit() for _ in range(5)] clbits = [Clbit() for _ in range(5)] qc = QuantumCircuit() qc.add_bits(qubits) qc.add_bits(clbits) qr = QuantumRegister(bits=qubits) cr = ClassicalRegister(bits=clbits) qc.add_register(qr) qc.add_register(cr) qr_standalone = QuantumRegister(2, "standalone") qc.add_register(qr_standalone) cr_standalone = ClassicalRegister(2, "classical_standalone") qc.add_register(cr_standalone) qc.unitary(random_unitary(32, seed=42), qr) qc.unitary(random_unitary(4, seed=100), qr_standalone) qc.measure(qr, cr) qc.measure(qr_standalone, cr_standalone) qpy_file = io.BytesIO() dump(qc, qpy_file) qpy_file.seek(0) new_circ = load(qpy_file)[0] self.assertEqual(qc, new_circ)
def generate_register_edge_cases(): """Generate register edge case circuits.""" register_edge_cases = [] # Circuit with shared bits in a register qubits = [Qubit() for _ in range(5)] shared_qc = QuantumCircuit() shared_qc.add_bits(qubits) shared_qr = QuantumRegister(bits=qubits) shared_qc.add_register(shared_qr) shared_qc.h(shared_qr) shared_qc.cx(0, 1) shared_qc.cx(0, 2) shared_qc.cx(0, 3) shared_qc.cx(0, 4) shared_qc.measure_all() register_edge_cases.append(shared_qc) # Circuit with registers that have a mix of standalone and shared register # bits qr = QuantumRegister(5, "foo") qr = QuantumRegister(name="bar", bits=qr[:3] + [Qubit(), Qubit()]) cr = ClassicalRegister(5, "foo") cr = ClassicalRegister(name="classical_bar", bits=cr[:3] + [Clbit(), Clbit()]) hybrid_qc = QuantumCircuit(qr, cr) hybrid_qc.h(0) hybrid_qc.cx(0, 1) hybrid_qc.cx(0, 2) hybrid_qc.cx(0, 3) hybrid_qc.cx(0, 4) hybrid_qc.measure(qr, cr) register_edge_cases.append(hybrid_qc) # Circuit with mixed standalone and shared registers qubits = [Qubit() for _ in range(5)] clbits = [Clbit() for _ in range(5)] mixed_qc = QuantumCircuit() mixed_qc.add_bits(qubits) mixed_qc.add_bits(clbits) qr = QuantumRegister(bits=qubits) cr = ClassicalRegister(bits=clbits) mixed_qc.add_register(qr) mixed_qc.add_register(cr) qr_standalone = QuantumRegister(2, "standalone") mixed_qc.add_register(qr_standalone) cr_standalone = ClassicalRegister(2, "classical_standalone") mixed_qc.add_register(cr_standalone) mixed_qc.unitary(random_unitary(32, seed=42), qr) mixed_qc.unitary(random_unitary(4, seed=100), qr_standalone) mixed_qc.measure(qr, cr) mixed_qc.measure(qr_standalone, cr_standalone) register_edge_cases.append(mixed_qc) # Circuit with out of order register bits qr_standalone = QuantumRegister(2, "standalone") qubits = [Qubit() for _ in range(5)] clbits = [Clbit() for _ in range(5)] ooo_qc = QuantumCircuit() ooo_qc.add_bits(qubits) ooo_qc.add_bits(clbits) random.seed(42) random.shuffle(qubits) random.shuffle(clbits) qr = QuantumRegister(bits=qubits) cr = ClassicalRegister(bits=clbits) ooo_qc.add_register(qr) ooo_qc.add_register(cr) qr_standalone = QuantumRegister(2, "standalone") cr_standalone = ClassicalRegister(2, "classical_standalone") ooo_qc.add_bits([qr_standalone[1], qr_standalone[0]]) ooo_qc.add_bits([cr_standalone[1], cr_standalone[0]]) ooo_qc.add_register(qr_standalone) ooo_qc.add_register(cr_standalone) ooo_qc.unitary(random_unitary(32, seed=42), qr) ooo_qc.unitary(random_unitary(4, seed=100), qr_standalone) ooo_qc.measure(qr, cr) ooo_qc.measure(qr_standalone, cr_standalone) register_edge_cases.append(ooo_qc) return register_edge_cases