def test_create_program_graphs():
calib_time = datetime(year=2019, month=2, day=1,
hour=0, minute=0, second=0, tzinfo=timezone.utc)
qubit_list = []
ro_errors = [0.01, 0.01, 0.01]
for ro_error in ro_errors:
qubit_list.append(make_qubit_with_error(ro_error))
p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.9)]
g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1])
p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)]
g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2])
gate_list = [g01, g12]
bprop = BackendProperties(last_update_date=calib_time, backend_name="test_backend",
qubits=qubit_list, backend_version="1.0.0", gates=gate_list,
general=[])
circ_list = [random_circuit(2, 10, measure=True), random_circuit(
4, 10, measure=True), random_circuit(3, 10, measure=True), random_circuit(5, 10, measure=True)]
dag_list = [circuit_to_dag(circ) for circ in circ_list]
caml = CrosstalkAdaptiveMultiLayout(bprop)
num_q = caml._create_program_graphs(dag_list)
print(num_q)
heights = []
for dag in caml.dag_list:
height = dag.num_qubits()
heights.append(height)
print(heights)
def test_simple_random(self):
"""Test creating a simple random circuit.
"""
circ = random_circuit(num_qubits=5, depth=4)
self.assertIsInstance(circ, QuantumCircuit)
self.assertEqual(circ.width(), 5)
self.assertEqual(circ.depth(), 4)
def test_job(self):
"""Test retrieving a composite job."""
tags = ["test_job_set"]
circs_counts = [3, 4]
for count in circs_counts:
with self.subTest(count=count):
circs = []
for _ in range(count):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
circs = transpile(circs, backend=self.sim_backend)
job_set = self.sim_backend.run(
circs, max_circuits_per_job=2, job_tags=tags
)
job_set.block_for_submit()
self.assertEqual(job_set.tags(), tags)
rjob_set = self.dependencies.provider.backend.job(job_set.job_id())
self.assertIsInstance(rjob_set, IBMCompositeJob)
self.assertEqual(rjob_set.job_id(), job_set.job_id())
self.assertEqual(len(rjob_set.sub_jobs()), len(job_set.sub_jobs()))
self.assertEqual(
{rsub.job_id() for rsub in rjob_set.sub_jobs()},
{sub.job_id() for sub in job_set.sub_jobs()},
)
self.assertEqual(rjob_set.tags(), job_set.tags())
self.assertEqual(
job_set.result().to_dict(), rjob_set.result().to_dict()
)
job_circuits = job_set.circuits()
rjob_circuits = rjob_set.circuits()
self.assertEqual(len(job_circuits), count)
self.assertEqual(len(job_circuits), len(rjob_circuits))
for job_circ, rjob_circ in zip(job_circuits, rjob_circuits):
self.assertEqual(job_circ.data, rjob_circ.data)
def test_retry_failed_submit(self):
"""Test retrying failed job submit."""
max_circs = self.fake_backend.configuration().max_experiments
circs = []
count = 3
for _ in range(max_circs * (count - 1) + 1):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
sub_tests = [[0], [1, 2], [0, 2]]
for failed_index in sub_tests:
with self.subTest(failed_index=failed_index):
self._set_fake_client(JobSubmitFailClient(failed_indexes=failed_index))
job_set = self.fake_backend.run(circs)
job_set.wait_for_final_state()
self.assertEqual(job_set.status(), JobStatus.ERROR)
good_indexes = set(range(count)) - set(failed_index)
self.assertEqual(len(job_set.sub_jobs()), len(good_indexes))
good_ids = {job.job_id() for job in job_set.sub_jobs()}
job_set.rerun_failed()
job_set.wait_for_final_state()
self.assertEqual(job_set.status(), JobStatus.DONE)
self.assertEqual(len(job_set.sub_jobs()), count)
self.assertTrue(
good_ids.issubset({job.job_id() for job in job_set.sub_jobs()})
)
circ_idx = 0
for sub_job in job_set.sub_jobs():
for job_circ in sub_job.circuits():
self.assertEqual(job_circ, circs[circ_idx])
circ_idx += 1
self.assertEqual(job_set.circuits(), circs)
def growing_depth(n_qubits, n_circuits):
circuits = []
circ = QuantumCircuit(n_qubits)
for i in range(n_circuits):
circ = random_circuit(n_qubits, 1, measure=False).combine(circ)
circuits.append(circ)
return circuits, n_circuits
def add_custom_instruction(self):
backend = self.backend(max_job_size=1, max_shot_size=1)
circ = random_circuit(num_qubits=2, depth=4)
circ.save_statevector()
circ = transpile(circ, backend)
qobj = assemble(circ)
split_qobj(qobj, max_size=1, max_shot_size=1, qobj_id='testing')
def test_random_circuits(self):
for circuit_index in range(1000):
num_qubits = random.randrange(1, 6)
# Generate random circuit and transpile it to run on specific hardware
random_circ = transpile(
random_circuit(num_qubits, 5, measure=False),
self.quac_simulator)
random_circ.measure_all()
# Get QuaC-calculated probabilities in a list
plugin_probs = counts_to_dist(
execute(random_circ,
self.quac_simulator,
shots=1,
optimization_level=0,
quac_noise_model=QuacNoiseModel.get_noiseless_model(
5)).result().get_counts())
# Get Qiskit-calculated probabilities in a list
random_circ.remove_final_measurements(
) # avoid collapsing state vector
qiskit_sv = execute(
random_circ,
self.qasm_simulator,
shots=8000,
optimization_level=0,
).result().get_statevector(random_circ)
# qiskit_probs = qiskit_statevector_to_probabilities(qiskit_sv, 5)
qiskit_probs = statevector_to_probabilities(qiskit_sv)
# Calculate divergence of Qiskit and QuaC predictions
difference_angle = get_vec_angle(qiskit_probs, plugin_probs)
self.assertLess(difference_angle, 1e-5)
def test_random_measure(self):
"""Test random circuit with final measurement."""
num_qubits = depth = 3
circ = random_circuit(num_qubits, depth, measure=True)
self.assertEqual(circ.width(), 2 * num_qubits)
dag = circuit_to_dag(circ)
for nd in list(dag.topological_op_nodes())[-num_qubits:]:
self.assertIsInstance(nd.op, Measure)
def mutate(self, qc : QuantumCircuit):
# Delete a gate
if (random() < 0.75):
qc.data.pop(randint(0, len(qc.data) - 1))
if (random() < 0.25):
circ = random_circuit(qc.num_qubits, 1, measure=False)
qc.append(circ.to_instruction(), qc.qregs)
return qc
def generate_random_circuits():
"""Generate multiple random circuits."""
random_circuits = []
for i in range(10):
random_circuits.append(
random_circuit(10, 10, measure=True, conditional=True, reset=True, seed=42 + i)
)
return random_circuits
def test_split(self):
"""Circuits split test"""
backend = self.backend(max_job_size=1)
circs = [
random_circuit(num_qubits=2, depth=4, measure=True, seed=i)
for i in range(2)
]
circs = transpile(circs, backend)
self.split_compare(circs, backend)
def test_huge_circuit(self):
"""Test draw huge circuit."""
filename = self._get_resource_path('test_huge.tex')
qc = random_circuit(40, 40, 1)
try:
circuit_drawer(qc, filename=filename, output='latex_source')
self.assertNotEqual(os.path.exists(filename), False)
finally:
if os.path.exists(filename):
os.remove(filename)
def test_sub_job(self):
"""Test retrieving a single sub job."""
max_circs = 3
num_jobs = 3
circs = []
for _ in range(max_circs * (num_jobs - 1) + 1):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
job_set = self.fake_backend.run(circs, max_circuits_per_job=max_circs)
job_set.block_for_submit()
circ_idx = random.randint(0, len(circs) - 1)
self.assertIn(circs[circ_idx], job_set.sub_job(circ_idx).circuits())
def test_job_circuits(self):
"""Test job circuits."""
circs = []
for _ in range(3):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
circs_copied = circs.copy()
job_set = self.fake_backend.run(circs, max_circuits_per_job=1)
job_circuits = job_set.circuits()
self.assertEqual(job_circuits, circs_copied)
for i, sub_job in enumerate(job_set.sub_jobs()):
self.assertEqual(sub_job.circuits()[0], circs_copied[i])
def test_random_circuit_conditional_reset(self):
"""Test generating random circuits with conditional and reset."""
num_qubits = 1
depth = 100
circ = random_circuit(num_qubits,
depth,
conditional=True,
reset=True,
seed=5)
self.assertEqual(circ.width(), 2 * num_qubits)
self.assertIn("reset", circ.count_ops())
def prepare_circuits(backend):
"""Generate a random circuit.
Args:
backend (qiskit.providers.Backend): Backend used for transpilation.
Returns:
qiskit.QuantumCircuit: Generated circuit.
"""
circuit = random_circuit(num_qubits=5, depth=4, measure=True, seed=random.randint(0, 1000))
return transpile(circuit, backend)
def test_overcomplete_basis(self):
"""Test optimization with an overcomplete basis."""
circuit = random_circuit(3, 3, seed=42)
basis = ["rz", "rxx", "rx", "ry", "p", "sx", "u", "cx"]
passmanager = PassManager()
passmanager.append(BasisTranslator(sel, basis))
basis_translated = passmanager.run(circuit)
passmanager = PassManager()
passmanager.append(Optimize1qGatesDecomposition(basis))
result_full = passmanager.run(basis_translated)
self.assertTrue(Operator(circuit).equiv(Operator(result_full)))
self.assertGreater(basis_translated.depth(), result_full.depth())
def test_multiple_circuits(self):
"""Test multiple circuits can be serialized together."""
circuits = []
for i in range(10):
circuits.append(
random_circuit(10, 10, measure=True, conditional=True, reset=True, seed=42 + i)
)
qpy_file = io.BytesIO()
dump(circuits, qpy_file)
qpy_file.seek(0)
new_circs = load(qpy_file)
self.assertEqual(circuits, new_circs)
def test_execute(self, n_qubits, depth):
circuit = random_circuit(n_qubits,
depth,
reset=True,
measure=True,
seed=0)
transpiled = transpile(circuit,
pass_manager=level_3_with_contant_pure(
self.pm_conf))
expected = self.execute(circuit).result()
result = self.execute(transpiled).result()
self.assertEqualCounts(result, expected)
def generator(
): #This function generates random levels for Qflow based on user input
rd.seed() #set seed for random numbers
num_qubit = int(input('Enter the number of Qubits:')
) # take user input for number of qubits and depth.
depth = int(
input('Enter the circuit depth:')) # recomend 2 qubits for now.
end = False # end while loop flag
while end == False:
Circ = random_circuit(num_qubit, depth) # Generate a random circuit
Circ_Operator = Operator(Circ) #construct operator for the circuit
Unitary = Circ_Operator.data # extract the unitary as a 2D array
origin = np.zeros(
2**num_qubit) # define the origin vector of the state space
state = np.zeros(
2**
num_qubit) # create a random unnormalised state in the state space
for i in range(len(state)):
state[i] = rd.random()
length = distance.euclidean(origin, state)
state = state / length # normalise the state
flow = np.zeros(
(Unitary.shape[0], Unitary.shape[1])) # define empt flow matrix
for n in range(Unitary.shape[0]): #fill flow matrix
for m in range(Unitary.shape[1]):
sum = 0
for i in range(Unitary.shape[1]):
sum += state[i] * Unitary[n, i]
flow[n, m] = ((state[m].conjugate()) *
(Unitary[n, m].conjugate()) * sum).real
if flow[n,
m] < 0: # check that at least one element is negative and if true end the loop
end = True
valid = FlowCheck(
Unitary, state, flow
) #Check that the generated matrix does indeed satisfy the required constraints using a second function.
if valid == True:
return Unitary, state, flow
elif valid == False:
print('An Error has occured restart the game.')
def test_repr_of_instructions(self):
"""Test the __repr__ method of the Instruction
class"""
ins1 = Instruction("test_instruction", 3, 5, [0, 1, 2, 3])
self.assertEqual(
repr(ins1),
"Instruction(name='{}', num_qubits={}, num_clbits={}, params={})".
format(ins1.name, ins1.num_qubits, ins1.num_clbits, ins1.params),
)
ins2 = random_circuit(num_qubits=4, depth=4,
measure=True).to_instruction()
self.assertEqual(
repr(ins2),
"Instruction(name='{}', num_qubits={}, num_clbits={}, params={})".
format(ins2.name, ins2.num_qubits, ins2.num_clbits, ins2.params),
)
def test_run():
IBMQ.load_account()
provider = IBMQ.get_provider(
hub='ibm-q-keio', group='keio-internal', project='keio-students')
backend = provider.get_backend("ibmq_toronto")
calib_time = datetime(year=2020, month=8, day=1,
hour=0, minute=0, second=0, tzinfo=timezone.utc)
bprop = backend.properties(datetime=calib_time)
circ = random_circuit(10, 3, measure=True, seed=1)
circ = decompose_to_base_gates(circ)
print(circ)
dag = circuit_to_dag(circ)
caml = CrosstalkAdaptiveMultiLayout(bprop)
caml.run(dag)
pprint(caml.property_set['layout'])
def test_run_with_Xtalk():
calib_time = datetime(year=2019, month=2, day=1,
hour=0, minute=0, second=0, tzinfo=timezone.utc)
qubit_list = []
ro_errors = [0.01]*6
for ro_error in ro_errors:
qubit_list.append(make_qubit_with_error(ro_error))
p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)]
p03 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)]
p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)]
p14 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.2)]
p35 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.3)]
p45 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)]
p25 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)]
g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1])
g03 = Gate(name="CX0_3", gate="cx", parameters=p03, qubits=[0, 3])
g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2])
g14 = Gate(name="CX1_4", gate="cx", parameters=p14, qubits=[1, 4])
g35 = Gate(name="CX3_5", gate="cx", parameters=p35, qubits=[3, 5])
g45 = Gate(name="CX4_5", gate="cx", parameters=p45, qubits=[4, 5])
g25 = Gate(name="CX2_5", gate="cx", parameters=p25, qubits=[2, 5])
gate_list = [g01, g03, g12, g14, g35, g45, g25]
bprop = BackendProperties(
last_update_date=calib_time, backend_name="test_backend",
qubits=qubit_list, backend_version="1.0.0", gates=gate_list,
general=[])
xtalk_prop = {(2, 5): {(0, 1): 5},
(1, 0): {(2, 5): 5},
}
circ = random_circuit(6, 3, measure=True, seed=1)
circ = decompose_to_base_gates(circ)
print(circ)
dag = circuit_to_dag(circ)
caml_noXtalk = CrosstalkAdaptiveMultiLayout(bprop)
caml_noXtalk.run(dag)
pprint(caml_noXtalk.property_set['layout'])
caml_Xtalk = CrosstalkAdaptiveMultiLayout(bprop, crosstalk_prop=xtalk_prop)
caml_Xtalk.run(dag)
pprint(caml_Xtalk.property_set['layout'])
def test_noise_model_to_and_from_array(self):
random_circs = [random_circuit(5, 5, measure=True) for _ in range(100)]
true_t1 = [1000 * (1 + random.random()) for _ in range(5)]
true_t2 = [10000 * (1 + random.random()) for _ in range(5)]
# Develop random measurement matrices for each qubit of the form
# [ P(0|0) P(0|1) ]
# [ P(1|0) P(1|1) ]
meas_mats = []
for _ in range(5):
stay_zero = random.random()
stay_one = random.random()
meas_mats.append(
np.array([
[stay_zero, 1 - stay_one],
[1 - stay_zero, stay_one]
])
)
zz = {}
for qubit1 in range(5):
for qubit2 in range(5):
if qubit1 != qubit2:
zz[(qubit1, qubit2)] = random.randrange(1, 10) * 1e-5
random_quac_noise_model = QuacNoiseModel(
true_t1,
true_t2,
[meas_mats[0] for _ in range(5)],
None
)
recovered_quac_noise_model = QuacNoiseModel.from_array(random_quac_noise_model.to_array(), 5)
for circ in random_circs:
transpiled_circ = transpile(circ, self.quac_sim, optimization_level=0)
dist_original = execute(transpiled_circ, self.quac_sim,
quac_noise_model=random_quac_noise_model,
optimization_level=0).result().get_counts()
dist_recovered = execute(transpiled_circ, self.quac_sim,
quac_noise_model=recovered_quac_noise_model,
optimization_level=0).result().get_counts()
self.assertEqual(dist_original, dist_recovered)
def test_retry_failed_jobs(self):
"""Test retrying failed jobs."""
max_circs = 3
num_jobs = 3
circs = []
for _ in range(max_circs * (num_jobs - 1) + 1):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
sub_tests = [
[FailedFakeJob, BaseFakeJob, BaseFakeJob],
[BaseFakeJob, FailedFakeJob, CancelableFakeJob],
[CancelableFakeJob, BaseFakeJob, FailedFakeJob],
]
for job_class in sub_tests:
with self.subTest(job_class=job_class):
self._set_fake_client(BaseFakeAccountClient(job_class=job_class))
job_set = self.fake_backend.run(circs, max_circuits_per_job=max_circs)
time.sleep(3)
for subjob in job_set.sub_jobs():
if subjob.status() == JobStatus.RUNNING:
subjob.cancel()
job_set.wait_for_final_state()
self.assertEqual(job_set.status(), JobStatus.ERROR)
good_ids = {
job.job_id()
for job in job_set.sub_jobs()
if job.status() == JobStatus.DONE
}
job_set.rerun_failed()
job_set.wait_for_final_state()
self.assertEqual(job_set.status(), JobStatus.DONE)
self.assertEqual(len(job_set.sub_jobs()), num_jobs)
self.assertTrue(
good_ids.issubset({job.job_id() for job in job_set.sub_jobs()})
)
circ_idx = 0
for sub_job in job_set.sub_jobs():
for job_circ in sub_job.circuits():
self.assertEqual(job_circ, circs[circ_idx])
circ_idx += 1
self.assertEqual(job_set.circuits(), circs)
def run_random_circuits(backend, shots=None, **run_options):
"""Test random circuits on different executor fictures"""
job_size = 10
circuits = [
random_circuit(num_qubits=2, depth=2, seed=i) for i in range(job_size)
]
# Sample references counts
targets = []
for circ in circuits:
state = Statevector(circ)
state.seed = 101
targets.append(state.sample_counts(shots=shots))
# Add measurements for simulation
for circ in circuits:
circ.measure_all()
circuits = transpile(circuits, backend)
job = backend.run(circuits, shots=shots, **run_options)
result = job.result()
return result, circuits, targets
def test_initialize_backend_prop():
circ_list = [random_circuit(2, 2) for _ in range(10)]
dag_list = [circuit_to_dag(circ) for circ in circ_list]
calib_time = datetime(year=2019, month=2, day=1,
hour=0, minute=0, second=0, tzinfo=timezone.utc)
qubit_list = []
ro_errors = [0.01, 0.01, 0.01]
for ro_error in ro_errors:
qubit_list.append(make_qubit_with_error(ro_error))
p01 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.9)]
g01 = Gate(name="CX0_1", gate="cx", parameters=p01, qubits=[0, 1])
p12 = [Nduv(date=calib_time, name='gate_error', unit='', value=0.1)]
g12 = Gate(name="CX1_2", gate="cx", parameters=p12, qubits=[1, 2])
gate_list = [g01, g12]
bprop = BackendProperties(last_update_date=calib_time, backend_name="test_backend",
qubits=qubit_list, backend_version="1.0.0", gates=gate_list,
general=[])
caml = CrosstalkAdaptiveMultiLayout(bprop)
caml._initialize_backend_prop()
def generate(
self,
num_multi_circ: int,
num_circ: Union[int, List[int]],
circ_size: Optional[Union[Tuple[int], List[Tuple[int]],
List[List[Tuple[int]]]]] = None,
seed: Optional[Union[int, List[int], List[List[int]]]] = None,
):
"""
Args:
num_multi_circ : number of multi-tasking circuit you want to make
num_circ : The number of circuits containd in the multi-tasking circuit
circ_size : width and depth of random circuit [w, d]
random_seed : seed to make random circuit
Return:
The list of multi-circuit set or just single multi-circuit set
multi-circuit set: the list of qc to make multi-tasking circuit
"""
multi_circuits_list = []
num_circ_list = self.parse_num_circ(num_circ)
circ_size = self.parse_circ_size(circ_size, num_circ_list)
seed_list_list = self.parse_seed(seed, num_circ_list)
for mqc_id, num_circ in enumerate(num_circ_list):
rand_qc_list = []
for qc_id in range(num_circ):
width = circ_size[mqc_id][qc_id][0]
depth = circ_size[mqc_id][qc_id][1]
seed = seed_list_list[mqc_id][qc_id]
rand_qc = random_circuit(width, depth, measure=True, seed=seed)
rand_qc_list.append(rand_qc)
multi_circuits_list.append(rand_qc_list)
if num_multi_circ == 1:
return multi_circuits_list[0]
return multi_circuits_list
logging.basicConfig(level=logging.DEBUG)
"""
WARNING: seems not work on server, reasons unknown yet
"""
# import pdb
# pdb.set_trace()
provider = IBMQ.load_account()
backend = provider.get_backend('ibmqx2')
# Build a thousand circuits.
circs = []
for _ in range(1000):
circs.append(random_circuit(num_qubits=2, depth=3, measure=True))
# Need to transpile the circuits first.
circs = transpile(circs, backend=backend)
print('here1')
# Use Job Manager to break the circuits into multiple jobs.
job_manager = IBMQJobManager()
job_set_foo = job_manager.run(circs, backend=backend, name='foo')
print('here2')
results = job_set_foo.results()
results.get_counts(5) # Counts for experiment 5.
def test_random_depth_0(self):
"""Test random depth 0 circuit.
"""
circ = random_circuit(num_qubits=1, depth=0)
self.assertEqual(circ.width(), 1)
self.assertEqual(circ.depth(), 0)
