def tensored_meas_cal(mit_pattern=None, qr=None, cr=None, circlabel=''):
"""
Return a list of calibration circuits
Args:
mit_pattern (list of lists of integers): Qubits to perform the
measurement correction on, divided to groups according to tensors.
if None and qr is given then assumed to be performed over the entire
qr as one group
qr (QuantumRegister): A quantum register. If none one is created
cr (ClassicalRegister): A classical register. If none one is created
circlabel: A string to add to the front of circuit names for
unique identification
Returns:
A list of two QuantumCircuit objects containing the calibration
circuits
mit_pattern
Additional Information:
The returned circuits are named circlabel+cal_XXX
where XXX is the basis state,
e.g., cal_000 and cal_111
Pass the results of these circuits to the TensoredMeasurementFitter
constructor
"""
if mit_pattern is None and qr is None:
raise QiskitError("Must give one of mit_pattern or qr")
qubits_in_pattern = []
if mit_pattern is not None:
for qubit_list in mit_pattern:
for qubit in qubit_list:
if qubit in qubits_in_pattern:
raise QiskitError("mit_pattern cannot contain \
multiple instances of the same qubit")
qubits_in_pattern.append(qubit)
# Create the registers if not already done
if qr is None:
qr = QuantumRegister(max(qubits_in_pattern) + 1)
else:
qubits_in_pattern = range(len(qr))
mit_pattern = [qubits_in_pattern]
nqubits = len(qubits_in_pattern)
# create classical bit registers
if cr is None:
cr = ClassicalRegister(nqubits)
qubits_list_sizes = [len(qubit_list) for qubit_list in mit_pattern]
nqubits = sum(qubits_list_sizes)
size_of_largest_group = max([list_size for list_size in qubits_list_sizes])
largest_labels = count_keys(size_of_largest_group)
state_labels = []
for largest_state in largest_labels:
basis_state = ''
for list_size in qubits_list_sizes:
basis_state = largest_state[:list_size] + basis_state
state_labels.append(basis_state)
cal_circuits = []
for basis_state in state_labels:
qc_circuit = QuantumCircuit(qr,
cr,
name='%scal_%s' % (circlabel, basis_state))
end_index = nqubits
for qubit_list, list_size in zip(mit_pattern, qubits_list_sizes):
start_index = end_index - list_size
substate = basis_state[start_index:end_index]
for qind in range(list_size):
if substate[list_size - qind - 1] == '1':
qc_circuit.x(qr[qubit_list[qind]])
end_index = start_index
qc_circuit.barrier(qr)
# add measurements
end_index = nqubits
for qubit_list, list_size in zip(mit_pattern, qubits_list_sizes):
for qind in range(list_size):
qc_circuit.measure(qr[qubit_list[qind]],
cr[nqubits - (end_index - qind)])
end_index -= list_size
cal_circuits.append(qc_circuit)
return cal_circuits, mit_pattern
def test_circuit_depth_no_reg(self):
"""Test depth of no register circuits
"""
qc = QuantumCircuit()
self.assertEqual(qc.depth(), 0)
def test_from_circuit(self):
"""Test initialization from a circuit."""
# random unitaries
u0 = random_unitary(2).data
u1 = random_unitary(2).data
# add to circuit
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.unitary(u0, [qr[0]])
circ.unitary(u1, [qr[1]])
target = Statevector(np.kron(u1, u0).dot([1, 0, 0, 0]))
vec = Statevector.from_instruction(circ)
self.assertEqual(vec, target)
# Test tensor product of 1-qubit gates
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.x(1)
circuit.ry(np.pi / 2, 2)
target = Statevector.from_label("000").evolve(Operator(circuit))
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
# Test decomposition of Controlled-Phase gate
lam = np.pi / 4
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cp(lam, 0, 1)
target = Statevector.from_label("00").evolve(Operator(circuit))
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
# Test decomposition of controlled-H gate
circuit = QuantumCircuit(2)
circ.x(0)
circuit.ch(0, 1)
target = Statevector.from_label("00").evolve(Operator(circuit))
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
# Test custom controlled gate
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
gate = qc.to_gate()
gate_ctrl = gate.control()
circuit = QuantumCircuit(3)
circuit.x(0)
circuit.append(gate_ctrl, range(3))
target = Statevector.from_label("000").evolve(Operator(circuit))
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
# Test initialize instruction
target = Statevector([1, 0, 0, 1j]) / np.sqrt(2)
circuit = QuantumCircuit(2)
circuit.initialize(target.data, [0, 1])
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
# Test reset instruction
target = Statevector([1, 0])
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.reset(0)
psi = Statevector.from_instruction(circuit)
self.assertEqual(psi, target)
def test_circuit_connected_components_empty(self):
"""Verify num_connected_components is width for empty
"""
q = QuantumRegister(7, 'q')
qc = QuantumCircuit(q)
self.assertEqual(7, qc.num_connected_components())
def test_num_qubits_registerless_circuit(self):
"""Check output for circuits with direct argument for qubits.
"""
circ = QuantumCircuit(5)
self.assertEqual(circ.num_qubits, 5)
def test_mapping_correction(self):
"""Test mapping works in previous failed case.
"""
backend = FakeRueschlikon()
qr = QuantumRegister(name='qr', size=11)
cr = ClassicalRegister(name='qc', size=11)
circuit = QuantumCircuit(qr, cr)
circuit.u3(1.564784764685993, -1.2378965763410095, 2.9746763177861713, qr[3])
circuit.u3(1.2269835563676523, 1.1932982847014162, -1.5597357740824318, qr[5])
circuit.cx(qr[5], qr[3])
circuit.u1(0.856768317675967, qr[3])
circuit.u3(-3.3911273825190915, 0.0, 0.0, qr[5])
circuit.cx(qr[3], qr[5])
circuit.u3(2.159209321625547, 0.0, 0.0, qr[5])
circuit.cx(qr[5], qr[3])
circuit.u3(0.30949966910232335, 1.1706201763833217, 1.738408691990081, qr[3])
circuit.u3(1.9630571407274755, -0.6818742967975088, 1.8336534616728195, qr[5])
circuit.u3(1.330181833806101, 0.6003162754946363, -3.181264980452862, qr[7])
circuit.u3(0.4885914820775024, 3.133297443244865, -2.794457469189904, qr[8])
circuit.cx(qr[8], qr[7])
circuit.u1(2.2196187596178616, qr[7])
circuit.u3(-3.152367609631023, 0.0, 0.0, qr[8])
circuit.cx(qr[7], qr[8])
circuit.u3(1.2646005789809263, 0.0, 0.0, qr[8])
circuit.cx(qr[8], qr[7])
circuit.u3(0.7517780502091939, 1.2828514296564781, 1.6781179605443775, qr[7])
circuit.u3(0.9267400575390405, 2.0526277839695153, 2.034202361069533, qr[8])
circuit.u3(2.550304293455634, 3.8250017126569698, -2.1351609599720054, qr[1])
circuit.u3(0.9566260876600556, -1.1147561503064538, 2.0571590492298797, qr[4])
circuit.cx(qr[4], qr[1])
circuit.u1(2.1899329069137394, qr[1])
circuit.u3(-1.8371715243173294, 0.0, 0.0, qr[4])
circuit.cx(qr[1], qr[4])
circuit.u3(0.4717053496327104, 0.0, 0.0, qr[4])
circuit.cx(qr[4], qr[1])
circuit.u3(2.3167620677708145, -1.2337330260253256, -0.5671322899563955, qr[1])
circuit.u3(1.0468499525240678, 0.8680750644809365, -1.4083720073192485, qr[4])
circuit.u3(2.4204244021892807, -2.211701932616922, 3.8297006565735883, qr[10])
circuit.u3(0.36660280497727255, 3.273119149343493, -1.8003362351299388, qr[6])
circuit.cx(qr[6], qr[10])
circuit.u1(1.067395863586385, qr[10])
circuit.u3(-0.7044917541291232, 0.0, 0.0, qr[6])
circuit.cx(qr[10], qr[6])
circuit.u3(2.1830003849921527, 0.0, 0.0, qr[6])
circuit.cx(qr[6], qr[10])
circuit.u3(2.1538343756723917, 2.2653381826084606, -3.550087952059485, qr[10])
circuit.u3(1.307627685019188, -0.44686656993522567, -2.3238098554327418, qr[6])
circuit.u3(2.2046797998462906, 0.9732961754855436, 1.8527865921467421, qr[9])
circuit.u3(2.1665254613904126, -1.281337664694577, -1.2424905413631209, qr[0])
circuit.cx(qr[0], qr[9])
circuit.u1(2.6209599970201007, qr[9])
circuit.u3(0.04680566321901303, 0.0, 0.0, qr[0])
circuit.cx(qr[9], qr[0])
circuit.u3(1.7728411151289603, 0.0, 0.0, qr[0])
circuit.cx(qr[0], qr[9])
circuit.u3(2.4866395967434443, 0.48684511243566697, -3.0069186877854728, qr[9])
circuit.u3(1.7369112924273789, -4.239660866163805, 1.0623389015296005, qr[0])
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits = transpile(circuit, backend)
self.assertIsInstance(circuits, QuantumCircuit)
"""
In this example a Bell state is made.
"""
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit_qcgpu_provider import QCGPUProvider
Provider = QCGPUProvider()
# Create a Quantum Register with 2 qubits.
q = QuantumRegister(2)
# Create a Quantum Circuit with 2 Qubits
qc = QuantumCircuit(q)
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(q[0])
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(q[0], q[1])
# See a list of available local simulators
print("QCGPU backends: ", Provider.backends())
backend_sim = Provider.get_backend('statevector_simulator')
# Compile and run the Quantum circuit on a simulator backend
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
# Show the results
print("Simulation Results: ", result_sim)
def search(N, oracle, provider_name, backend_name, token, shots, draw, file):
print("Grover's Search Algorithm Tool v.{}".format(__version__))
print("Params: N = {}, Oracle = {}, Backend = {}/{}, Shots = {}".format(
N, oracle, provider_name, backend_name, shots))
controlsCount = math.ceil(math.log2(N))
controls = QuantumRegister(controlsCount, "c_qb")
ancilla = QuantumRegister(1, "a_qb")
target = QuantumRegister(1, "t_qb")
classical = ClassicalRegister(controlsCount, "c_b")
iterations = int(math.pi / 4 * math.log2(N))
print("Quantum circuit: {} qubits, {} iteration(s)".format(
controlsCount + 2, iterations))
print("Building...")
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(controls, ancilla, target, classical)
# State preparation
# Add a H gates to contol qubits
circuit.h(controls)
# |-> to target qubit
circuit.x(target)
circuit.h(target)
# Grover iterator
def grover(circuit, controls, target):
# Oracle
binary = format(oracle, "0{}b".format(controlsCount))
for c, qubit in zip(binary, reversed(controls)):
if c == '0':
circuit.x(qubit)
circuit.mct(controls, target[0], ancilla, mode='advanced')
for c, qubit in zip(binary, reversed(controls)):
if c == '0':
circuit.x(qubit)
# Diffuser
circuit.h(controls)
circuit.x(controls)
circuit.mct(controls, target[0], ancilla, mode='advanced')
circuit.x(controls)
circuit.h(controls)
# Iterations
for i in range(iterations):
grover(circuit, controls, target)
# Measurement
circuit.measure(controls, classical)
# Draw quantum circuit
if draw:
if bool(file):
f = open(file, "w+")
print(circuit, file=f)
f.close()
else:
print(circuit)
# Backend
# Aer
if provider_name == "Aer":
backend = Aer.get_backend(backend_name)
# IBMQ
elif provider_name == "IBMQ":
account = IBMQ.stored_account()
if bool(account):
provider = IBMQ.load_account()
else:
if bool(token):
provider = IBMQ.enable_account(token)
else:
print("Token is not provided!")
exit()
backend = provider.get_backend(backend_name)
# Execute the quantum circuit on the qasm simulator
print("Executing...")
job = execute(circuit, backend, shots=shots)
# Wait results
i = 0
while True:
time.sleep(1)
status = job.status()
print("({}) {}".format(i, status))
i = i + 1
if status in JOB_FINAL_STATES:
if status == JobStatus.ERROR:
print("Error:", job.error_message())
exit()
else:
break
# Get results from the job
result = job.result()
#print("\nResults:", result)
# Find max counts
max = 0
state = ""
for k, v in result.get_counts(circuit).items():
if v > max:
max = v
state = k
num = int(state, 2)
print("Answer: {}, State: '{}', {} times".format(num, state, max))
return num
from qiskit import execute, Aer, QuantumCircuit
from math import pi, sqrt
# first measurement
qc = QuantumCircuit(1, 2)
backend = Aer.get_backend('qasm_simulator')
statevector = [1 / sqrt(2), 1j / sqrt(2)]
qc.initialize(statevector, 0)
qc.measure(0, 0)
qc.measure(0, 1)
print(qc)
result = execute(qc, backend).result()
counts = result.get_counts()
print(counts)
def _circuit(self) -> QuantumCircuit:
n_qubits: int = self._n_qubits
circuit: QuantumCircuit = QuantumCircuit(n_qubits)
circuit.h(range(n_qubits))
circuit.measure_all()
return circuit
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[0]) # number=57
prog.cz(input_qubit[4],input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=59
prog.z(input_qubit[4]) # number=55
prog.cx(input_qubit[4],input_qubit[0]) # number=56
prog.h(input_qubit[2]) # number=50
prog.cz(input_qubit[4],input_qubit[2]) # number=51
prog.h(input_qubit[2]) # number=52
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=28
prog.h(input_qubit[0]) # number=66
prog.cz(input_qubit[3],input_qubit[0]) # number=67
prog.h(input_qubit[0]) # number=68
prog.z(input_qubit[3]) # number=61
prog.cx(input_qubit[3],input_qubit[0]) # number=62
prog.cz(input_qubit[1],input_qubit[0]) # number=29
prog.h(input_qubit[0]) # number=30
prog.h(input_qubit[0]) # number=43
prog.cz(input_qubit[1],input_qubit[0]) # number=44
prog.h(input_qubit[0]) # number=45
prog.cx(input_qubit[1],input_qubit[0]) # number=35
prog.cx(input_qubit[1],input_qubit[0]) # number=38
prog.x(input_qubit[0]) # number=39
prog.cx(input_qubit[1],input_qubit[0]) # number=40
prog.cx(input_qubit[1],input_qubit[0]) # number=37
prog.h(input_qubit[0]) # number=46
prog.cz(input_qubit[1],input_qubit[0]) # number=47
prog.h(input_qubit[0]) # number=48
prog.h(input_qubit[0]) # number=63
prog.cz(input_qubit[1],input_qubit[0]) # number=64
prog.h(input_qubit[0]) # number=65
prog.x(input_qubit[1]) # number=10
prog.x(input_qubit[2]) # number=11
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.cx(input_qubit[0],input_qubit[1]) # number=22
prog.y(input_qubit[2]) # number=41
prog.x(input_qubit[1]) # number=23
prog.cx(input_qubit[0],input_qubit[1]) # number=24
prog.rx(1.0398671683382215,input_qubit[2]) # number=31
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def __init__(self):
super().__init__()
self.qc = QuantumCircuit()
self.enable_variadic = bool(variadic_gates)
def test_unitary_decomposition(self):
"""Test decomposition for unitary gates over 2 qubits."""
qc = QuantumCircuit(3)
qc.unitary(random_unitary(8, seed=42), [0, 1, 2])
self.assertTrue(Operator(qc).equiv(Operator(qc.decompose())))
from qiskit import compile, Aer
###############################################################
# Set the backend name and coupling map.
###############################################################
coupling_map = [[0, 1], [0, 2], [1, 2], [3, 2], [3, 4], [4, 2]]
backend = Aer.get_backend("qasm_simulator")
###############################################################
# Make a quantum program for quantum teleportation.
###############################################################
q = QuantumRegister(3, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c0, c1, c2, name="teleport")
# Prepare an initial state
qc.u3(0.3, 0.2, 0.1, q[0])
# Prepare a Bell pair
qc.h(q[1])
qc.cx(q[1], q[2])
# Barrier following state preparation
qc.barrier(q)
# Measure in the Bell basis
qc.cx(q[0], q[1])
qc.h(q[0])
qc.measure(q[0], c0[0])
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
prog.h(input_qubit[0]) # number=43
prog.cz(input_qubit[4],input_qubit[0]) # number=44
prog.h(input_qubit[0]) # number=45
prog.cx(input_qubit[4],input_qubit[0]) # number=46
prog.cx(input_qubit[4],input_qubit[0]) # number=52
prog.z(input_qubit[4]) # number=53
prog.cx(input_qubit[4],input_qubit[0]) # number=54
prog.cx(input_qubit[4],input_qubit[0]) # number=48
prog.h(input_qubit[0]) # number=37
prog.cz(input_qubit[4],input_qubit[0]) # number=38
prog.h(input_qubit[0]) # number=39
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.rx(-1.0430087609918113,input_qubit[4]) # number=36
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[1],input_qubit[0]) # number=40
prog.x(input_qubit[0]) # number=41
prog.h(input_qubit[0]) # number=49
prog.cz(input_qubit[1],input_qubit[0]) # number=50
prog.h(input_qubit[0]) # number=51
prog.x(input_qubit[1]) # number=10
prog.rx(-0.06597344572538572,input_qubit[3]) # number=27
prog.cx(input_qubit[0],input_qubit[2]) # number=22
prog.x(input_qubit[2]) # number=23
prog.h(input_qubit[2]) # number=28
prog.cz(input_qubit[0],input_qubit[2]) # number=29
prog.h(input_qubit[2]) # number=30
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[4]) # number=35
prog.h(input_qubit[0]) # number=17
prog.rx(2.4912829742967055,input_qubit[2]) # number=26
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[2]) # number=25
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 29 18:38:23 2020
@author: Neil Gupte
"""
import numpy as np
from qiskit import(QuantumCircuit, execute, Aer)
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
circuit1 = QuantumCircuit(2, 2)
circuit1.h(0)
circuit1.draw()
circuit1.x(1)
circuit1.cx(0, 1)
circuit1.draw()
circuit1.measure([0,1], [0,1])
job1 = execute(circuit1, simulator, shots=1000)
# Grab results from the job
result1 = job1.result()
# Returns counts
counts1 = result1.get_counts(circuit1)
print("\nTotal count for 10 and 01 are:",counts1)
plot_histogram(result1.get_counts(circuit1))
def make_circuit(n: int, f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.rx(-1.3603096190043806, input_qubit[2]) # number=28
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2**n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[3]) # number=34
prog.cz(input_qubit[4], input_qubit[3]) # number=35
prog.h(input_qubit[3]) # number=36
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1], input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.x(input_qubit[0]) # number=32
prog.cx(input_qubit[1], input_qubit[0]) # number=33
prog.cx(input_qubit[0], input_qubit[1]) # number=24
prog.x(input_qubit[1]) # number=25
prog.x(input_qubit[1]) # number=41
prog.cx(input_qubit[0], input_qubit[1]) # number=26
prog.x(input_qubit[2]) # number=11
prog.h(input_qubit[3]) # number=46
prog.cz(input_qubit[2], input_qubit[3]) # number=47
prog.h(input_qubit[3]) # number=48
prog.x(input_qubit[3]) # number=12
prog.h(input_qubit[2]) # number=42
if n >= 2:
prog.mcu1(pi, input_qubit[1:], input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.cx(input_qubit[0], input_qubit[2]) # number=43
prog.x(input_qubit[2]) # number=44
prog.cx(input_qubit[0], input_qubit[2]) # number=45
prog.rx(-1.9697785938008003, input_qubit[1]) # number=37
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.x(input_qubit[1]) # number=22
prog.x(input_qubit[1]) # number=23
# circuit end
return prog
def test_fusion_operations(self):
"""Test Fusion enable/disable option"""
shots = 100
qr = QuantumRegister(10)
cr = ClassicalRegister(10)
circuit = QuantumCircuit(qr, cr)
for i in range(10):
circuit.h(qr[i])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[0])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[1])
circuit.barrier(qr)
circuit.cx(qr[1], qr[0])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[0])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[1])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[3])
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.x(qr[1])
circuit.barrier(qr)
circuit.cx(qr[2], qr[3])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[3])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[3])
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.x(qr[1])
circuit.barrier(qr)
circuit.cx(qr[2], qr[3])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[3])
circuit.barrier(qr)
circuit.u3(0.1, 0.1, 0.1, qr[3])
circuit.barrier(qr)
circuit.measure(qr, cr)
qobj = assemble([circuit],
self.SIMULATOR,
shots=shots,
seed_simulator=1)
backend_options = self.BACKEND_OPTS.copy()
backend_options['fusion_enable'] = True
backend_options['fusion_verbose'] = True
backend_options['fusion_threshold'] = 1
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result_fusion = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
self.assertTrue(getattr(result_fusion, 'success', 'False'))
backend_options = self.BACKEND_OPTS.copy()
backend_options['fusion_enable'] = False
backend_options['fusion_verbose'] = True
backend_options['fusion_threshold'] = 1
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result_nonfusion = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
self.assertTrue(getattr(result_nonfusion, 'success', 'False'))
self.assertDictAlmostEqual(result_fusion.get_counts(circuit),
result_nonfusion.get_counts(circuit),
delta=0.0,
msg="fusion x-x-x was failed")
def setUp(self):
logger = getLogger()
logger.setLevel('DEBUG')
self.output = io.StringIO()
logger.addHandler(StreamHandlerRaiseException(self.output))
self.circuit = QuantumCircuit(QuantumRegister(1))
def build_circuit(n: int, f: Callable[[str], str]) -> QuantumCircuit:
# implement the Bernstein-Vazirani circuit
zero = np.binary_repr(0, n)
b = f(zero)
# initial n + 1 bits
input_qubit = QuantumRegister(n+1, "qc")
classicals = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classicals)
# inverse last one (can be omitted if using O_f^\pm)
prog.x(input_qubit[n])
# circuit begin
prog.h(input_qubit[1]) # number=1
prog.h(input_qubit[2]) # number=38
prog.cz(input_qubit[0],input_qubit[2]) # number=39
prog.h(input_qubit[2]) # number=40
prog.h(input_qubit[2]) # number=59
prog.cz(input_qubit[0],input_qubit[2]) # number=60
prog.h(input_qubit[2]) # number=61
prog.h(input_qubit[2]) # number=42
prog.cz(input_qubit[0],input_qubit[2]) # number=43
prog.h(input_qubit[2]) # number=44
prog.h(input_qubit[2]) # number=48
prog.cz(input_qubit[0],input_qubit[2]) # number=49
prog.h(input_qubit[2]) # number=50
prog.cx(input_qubit[0],input_qubit[2]) # number=54
prog.x(input_qubit[2]) # number=55
prog.h(input_qubit[2]) # number=67
prog.cz(input_qubit[0],input_qubit[2]) # number=68
prog.h(input_qubit[2]) # number=69
prog.h(input_qubit[2]) # number=64
prog.cz(input_qubit[0],input_qubit[2]) # number=65
prog.h(input_qubit[2]) # number=66
prog.h(input_qubit[2]) # number=71
prog.cz(input_qubit[0],input_qubit[2]) # number=72
prog.h(input_qubit[2]) # number=73
prog.h(input_qubit[2]) # number=51
prog.cz(input_qubit[0],input_qubit[2]) # number=52
prog.h(input_qubit[2]) # number=53
prog.h(input_qubit[2]) # number=25
prog.cz(input_qubit[0],input_qubit[2]) # number=26
prog.h(input_qubit[2]) # number=27
prog.h(input_qubit[1]) # number=7
prog.cz(input_qubit[2],input_qubit[1]) # number=8
prog.rx(0.17592918860102857,input_qubit[2]) # number=34
prog.rx(-0.3989822670059037,input_qubit[1]) # number=30
prog.h(input_qubit[1]) # number=9
prog.h(input_qubit[1]) # number=18
prog.rx(2.3310617489636263,input_qubit[2]) # number=58
prog.cz(input_qubit[2],input_qubit[1]) # number=19
prog.h(input_qubit[1]) # number=20
prog.x(input_qubit[1]) # number=62
prog.y(input_qubit[1]) # number=14
prog.h(input_qubit[1]) # number=22
prog.cz(input_qubit[2],input_qubit[1]) # number=23
prog.rx(-0.9173450548482197,input_qubit[1]) # number=57
prog.cx(input_qubit[2],input_qubit[1]) # number=63
prog.h(input_qubit[1]) # number=24
prog.z(input_qubit[2]) # number=3
prog.cx(input_qubit[2],input_qubit[1]) # number=70
prog.z(input_qubit[1]) # number=41
prog.x(input_qubit[1]) # number=17
prog.y(input_qubit[2]) # number=5
prog.x(input_qubit[2]) # number=21
# apply H to get superposition
for i in range(n):
prog.h(input_qubit[i])
prog.h(input_qubit[n])
prog.barrier()
# apply oracle O_f
oracle = build_oracle(n, f)
prog.append(
oracle.to_gate(),
[input_qubit[i] for i in range(n)] + [input_qubit[n]])
# apply H back (QFT on Z_2^n)
for i in range(n):
prog.h(input_qubit[i])
prog.barrier()
# measure
return prog
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
prog.cx(input_qubit[3],input_qubit[0]) # number=32
prog.z(input_qubit[3]) # number=33
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[3],input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.rx(0.11938052083641225,input_qubit[1]) # number=36
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.rx(1.4765485471872026,input_qubit[2]) # number=35
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.x(input_qubit[0]) # number=9
prog.x(input_qubit[4]) # number=30
prog.x(input_qubit[1]) # number=10
prog.x(input_qubit[2]) # number=11
prog.rx(-2.5258404934861938,input_qubit[1]) # number=25
prog.h(input_qubit[3]) # number=29
prog.cx(input_qubit[0],input_qubit[3]) # number=22
prog.x(input_qubit[3]) # number=23
prog.cx(input_qubit[0],input_qubit[3]) # number=24
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.rx(-0.0722566310325653,input_qubit[4]) # number=37
prog.x(input_qubit[1]) # number=14
prog.cx(input_qubit[0],input_qubit[2]) # number=26
prog.x(input_qubit[2]) # number=27
prog.cx(input_qubit[0],input_qubit[2]) # number=28
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def grover(marked_element):
# Determine the number of qubits needed
n = len(marked_element)
N = 2**n
# Flip bitstring - required due to the way qiskit marks strings
marked_element = marked_element[::-1]
# Determine the number of times to iterate
T = int(round(np.pi * np.sqrt(N) / 4 - 0.5))
print('Number of iterations T =', T)
# Initialise n qubit register, classical readout register and ancilla qubit
q = QuantumRegister(n, 'ctrl')
c = ClassicalRegister(n, 'meas')
a = QuantumRegister(n - 1, 'anc')
t = QuantumRegister(1, 'tgt')
# Combine resources into a quantum circuit
qc = QuantumCircuit(q, a, t, c)
# Step 1: Start with n qubit register in equal superposition
for i in range(n):
qc.h(q[i])
# Put the target ancilla qubit into the |-> state
qc.x(t[0])
qc.h(t[0])
# Define n-qubit CNOT gate
def MultiCNOT():
# Compute
qc.ccx(q[0], q[1], a[0])
for i in range(2, n):
qc.ccx(q[i], a[i - 2], a[i - 1])
# Copy
qc.cx(a[n - 2], t[0])
# Uncompute
for i in range(n - 1, 1, -1):
qc.ccx(q[i], a[i - 2], a[i - 1])
qc.ccx(q[0], q[1], a[0])
# Define the oracle
def U_f():
for j in range(n):
if marked_element[j] == '0':
qc.x(q[j])
MultiCNOT()
for j in range(n):
if marked_element[j] == '0':
qc.x(q[j])
# Define the gate D
def D():
# Apply H and X
for j in range(n):
qc.h(q[j])
qc.x(q[j])
MultiCNOT()
# Apply X and H
for j in range(n):
qc.x(q[j])
qc.h(q[j])
# Step 2: Repeat applications of U_f and D
for i in range(T):
U_f()
D()
# Measure our quantum register via our classical register
for i in range(n):
qc.measure(q[i], c[i])
# Execute the quantum circuit on the local simulator
job = execute(qc, 'local_qasm_simulator')
result = job.result()
print('The results of the simulation shots are:', result.get_counts(qc))
def test_num_qubits_qubitless_circuit(self):
"""Check output in absence of qubits.
"""
c_reg = ClassicalRegister(3)
circ = QuantumCircuit(c_reg)
self.assertEqual(circ.num_qubits, 0)
import numpy as np
from qiskit import (QuantumCircuit,QuantumRegister,ClassicalRegister,execute,Aer)
from qiskit.visualization import *
#Controlled-Z matrice cu CNOT si Hadamard si CNOT din C-Z cu Hadamard
#nr de qubiti
n=2
qr=n
#nr de biti
cr=n
#backend=Aer.get_backend('statevector_simulator')
simulator=Aer.get_backend('qasm_simulator')
dem1=QuantumCircuit(qr,cr)
circuit=QuantumCircuit(qr,cr)
dem2=QuantumCircuit(qr,cr)
circuit2=QuantumCircuit(qr,cr)
dem1.x(1)
dem1.cz(0,1)
dem2.x(0)
dem2.cx(0,1)
circuit.x(1)
# HXH=Z
#Hadamard
circuit.h(1)
#CNOT
circuit.cx(0,1)
#H
circuit.h(1)
def test_circuit_depth_empty(self):
"""Test depth of empty circuity
"""
q = QuantumRegister(5, 'q')
qc = QuantumCircuit(q)
self.assertEqual(qc.depth(), 0)
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.cx(input_qubit[0],input_qubit[4]) # number=54
prog.x(input_qubit[4]) # number=55
prog.cx(input_qubit[0],input_qubit[4]) # number=56
prog.cx(input_qubit[2],input_qubit[0]) # number=45
prog.z(input_qubit[2]) # number=46
prog.cx(input_qubit[2],input_qubit[0]) # number=47
prog.h(input_qubit[1]) # number=4
prog.rx(2.664070570244145,input_qubit[1]) # number=39
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[2]) # number=49
prog.cz(input_qubit[3],input_qubit[2]) # number=50
prog.h(input_qubit[2]) # number=51
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[3]) # number=40
prog.y(input_qubit[4]) # number=35
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=25
prog.cz(input_qubit[1],input_qubit[0]) # number=26
prog.h(input_qubit[0]) # number=27
prog.h(input_qubit[0]) # number=36
prog.cz(input_qubit[1],input_qubit[0]) # number=37
prog.h(input_qubit[0]) # number=38
prog.cx(input_qubit[1],input_qubit[0]) # number=41
prog.x(input_qubit[0]) # number=42
prog.cx(input_qubit[1],input_qubit[0]) # number=43
prog.cx(input_qubit[1],input_qubit[0]) # number=34
prog.cx(input_qubit[1],input_qubit[0]) # number=24
prog.cx(input_qubit[0],input_qubit[1]) # number=29
prog.cx(input_qubit[2],input_qubit[3]) # number=44
prog.x(input_qubit[1]) # number=30
prog.cx(input_qubit[0],input_qubit[1]) # number=31
prog.x(input_qubit[2]) # number=11
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.z(input_qubit[1]) # number=52
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
import matplotlib.pyplot as plt
import sys
import quantum_okiba as qo
from tqdm import tqdm
from qiskit import QuantumCircuit,visualization,Aer,execute
from qiskit.quantum_info import average_gate_fidelity
pi = np.pi
e = constants.e # [C]
h = constants.h # [m^2 kg/s]
hbar = constants.hbar
iDir = os.path.abspath(os.path.dirname(__file__))
opts = qt.solver.Options(nsteps=10000)
#回路を設計
circ = QuantumCircuit(2)
circ.h(0)
Image=circ.draw(output='mpl')
Image.savefig(iDir+'/sfg.png')
#回路を実行1
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend) #これでstatusとresultを得られる状態に
result = job.result()
outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)
#回路を実行2
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend) #これでstatusとresultを得られる状態に
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[1]) # number=29
prog.cz(input_qubit[3],input_qubit[1]) # number=30
prog.h(input_qubit[1]) # number=31
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1],input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.h(input_qubit[0]) # number=51
prog.cz(input_qubit[1],input_qubit[0]) # number=52
prog.h(input_qubit[0]) # number=53
prog.h(input_qubit[0]) # number=57
prog.cz(input_qubit[1],input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=59
prog.x(input_qubit[0]) # number=49
prog.cx(input_qubit[1],input_qubit[0]) # number=50
prog.h(input_qubit[0]) # number=54
prog.cz(input_qubit[1],input_qubit[0]) # number=55
prog.h(input_qubit[0]) # number=56
prog.h(input_qubit[4]) # number=41
prog.cx(input_qubit[1],input_qubit[0]) # number=37
prog.x(input_qubit[1]) # number=10
prog.h(input_qubit[2]) # number=25
prog.cz(input_qubit[0],input_qubit[2]) # number=26
prog.h(input_qubit[2]) # number=27
prog.x(input_qubit[2]) # number=23
prog.cx(input_qubit[0],input_qubit[2]) # number=24
prog.cx(input_qubit[0],input_qubit[3]) # number=32
prog.x(input_qubit[3]) # number=33
prog.h(input_qubit[3]) # number=42
prog.cz(input_qubit[0],input_qubit[3]) # number=43
prog.h(input_qubit[3]) # number=44
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
return prog
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.cx(input_qubit[0],input_qubit[2]) # number=35
prog.x(input_qubit[2]) # number=36
prog.cx(input_qubit[0],input_qubit[2]) # number=37
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(1):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.y(input_qubit[1]) # number=31
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[1],input_qubit[0]) # number=28
prog.x(input_qubit[0]) # number=29
prog.cx(input_qubit[1],input_qubit[0]) # number=30
prog.x(input_qubit[1]) # number=10
prog.cx(input_qubit[0],input_qubit[2]) # number=22
prog.cx(input_qubit[0],input_qubit[2]) # number=25
prog.x(input_qubit[2]) # number=26
prog.cx(input_qubit[0],input_qubit[2]) # number=27
prog.cx(input_qubit[0],input_qubit[2]) # number=24
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.rx(1.7404423300887455,input_qubit[1]) # number=32
prog.z(input_qubit[1]) # number=33
prog.h(input_qubit[3]) # number=20
prog.h(input_qubit[0])
prog.h(input_qubit[1])
prog.h(input_qubit[2])
prog.h(input_qubit[3])
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def complete_meas_cal(qubit_list=None, qr=None, cr=None, circlabel=''):
"""
Return a list of measurement calibration circuits for the full
Hilbert space.
Each of the 2**n circuits creates a basis state
Args:
qubit_list: A list of qubits to perform the measurement correction on,
if None and qr is given then assumed to be performed over the entire
qr. The calibration states will be labelled according to this ordering
qr (QuantumRegister): A quantum register. If none one is created
cr (ClassicalRegister): A classical register. If none one is created
circlabel: A string to add to the front of circuit names for
unique identification
Returns:
A list of QuantumCircuit objects containing the calibration circuits
A list of calibration state labels
Additional Information:
The returned circuits are named circlabel+cal_XXX
where XXX is the basis state,
e.g., cal_1001
Pass the results of these circuits to the CompleteMeasurementFitter
constructor
"""
if qubit_list is None and qr is None:
raise QiskitError("Must give one of a qubit_list or a qr")
# Create the registers if not already done
if qr is None:
qr = QuantumRegister(max(qubit_list) + 1)
if qubit_list is None:
qubit_list = range(len(qr))
cal_circuits = []
nqubits = len(qubit_list)
# create classical bit registers
if cr is None:
cr = ClassicalRegister(nqubits)
# labels for 2**n qubit states
state_labels = count_keys(nqubits)
for basis_state in state_labels:
qc_circuit = QuantumCircuit(qr,
cr,
name='%scal_%s' % (circlabel, basis_state))
for qind, _ in enumerate(basis_state):
if int(basis_state[nqubits - qind - 1]):
# the index labeling of the label is backwards with
# the list
qc_circuit.x(qr[qubit_list[qind]])
# add measurements
qc_circuit.measure(qr[qubit_list[qind]], cr[qind])
cal_circuits.append(qc_circuit)
return cal_circuits, state_labels
