def _generate_cqasm_from_circuit(circuit, full_state_projection=True):
run_config_dict = {'shots': 25, 'memory': True}
backend = QuantumInspireBackend(Mock(), Mock())
qobj = assemble(circuit, backend, **run_config_dict)
experiment = qobj.experiments[0]
simulator = QuantumInspireBackend(Mock(), Mock())
result = simulator._generate_cqasm(experiment, full_state_projection)
return result
def test_for_fsp_no_measurements(self):
with patch.object(QuantumInspireBackend,
"_submit_experiment",
return_value=Mock()) as result_experiment:
api = Mock()
project = {'id': 42}
api.create_project.return_value = project
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
simulator = QuantumInspireBackend(api, Mock())
instructions = [{
'name': 'cx',
'qubits': [0, 1]
}, {
'name': 'x',
'qubits': [0]
}]
experiment = self._basic_experiment_dictionary
experiment['instructions'] = instructions
qjob_dict = self._basic_qobj_dictionary
qjob_dict['experiments'][0] = experiment
qobj = QasmQobj.from_dict(qjob_dict)
experiment = qobj.experiments[0]
simulator.run(qobj)
result_experiment.assert_called_once_with(experiment,
25,
project=project,
full_state_projection=True)
def test_measurement_2_qubits_to_1_classical_bit(self):
with patch.object(QuantumInspireBackend,
"_submit_experiment",
return_value=Mock()):
api = Mock()
project = {'id': 42}
api.create_project.return_value = project
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
simulator = QuantumInspireBackend(api, Mock())
instructions = [{
'name': 'cx',
'qubits': [0, 1]
}, {
'memory': [0],
'name': 'measure',
'qubits': [0]
}, {
'name': 'x',
'qubits': [0]
}, {
'memory': [0],
'name': 'measure',
'qubits': [1]
}]
experiment = self._basic_experiment_dictionary
experiment['instructions'] = instructions
qjob_dict = self._basic_qobj_dictionary
qjob_dict['experiments'][0] = experiment
qobj = QasmQobj.from_dict(qjob_dict)
self.assertRaisesRegex(
QisKitBackendError,
'Measurement of different qubits to the same classical '
'register 0 is not supported', simulator.run, qobj)
def test_retrieve_job_with_error(self):
api = Mock(side_effect=ErrorMessage(error='404'))
api.get_project.side_effect = ErrorMessage(error='404')
backend = QuantumInspireBackend(api, QuantumInspireProvider())
with self.assertRaises(QisKitBackendError) as error:
backend.retrieve_job('wrong')
self.assertEqual(("Could not retrieve job with job_id 'wrong' ",), error.exception.args)
def test_validate_nr_classical_qubits_less_than_nr_qubits_conditional_gate(
self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
simulator = QuantumInspireBackend(api, Mock())
instructions = [{
'mask': '0xF',
'name': 'bfunc',
'register': 2,
'relation': '==',
'val': '0x1'
}, {
'conditional': 2,
'name': 'cx',
'qubits': [0, 1]
}, {
'memory': [1],
'name': 'measure',
'qubits': [0]
}]
qobj_dict = self._basic_qobj_dictionary
job_dict = self._basic_qobj_dictionary
qobj_dict['experiments'][0]['instructions'] = instructions
job_dict['experiments'][0]['header']['memory_slots'] = 3
job = qiskit.qobj.Qobj.from_dict(job_dict)
self.assertRaisesRegex(
QisKitBackendError,
'Number of classical bits must be less than or equal to the'
' number of qubits when using conditional gate operations',
simulator.run, job)
def test_get_experiment_results_returns_correct_value(self):
number_of_shots = 100
instructions = [{'name': 'h', 'qubits': [0]},
{'name': 'cx', 'qubits': [0, 1]},
{'name': 'measure', 'qubits': [1], 'memory': [1]},
{'name': 'measure', 'qubits': [0], 'memory': [0]}]
experiment = self._instructions_to_two_qubit_experiment(instructions)
api = Mock()
api.get_result_from_job.return_value = {'id': 1, 'histogram': {'1': 0.6, '3': 0.4},
'execution_time_in_seconds': 2.1, 'number_of_qubits': 2,
'raw_data_url': 'http://saevar-qutech-nginx/api/results/24/raw-data/'}
api.get_raw_data_from_result.return_value = [1] * 60 + [3] * 40
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {'name': 'name', 'memory_slots': 2,
'creg_sizes': [['c1', 2]], 'measurements': measurements}
jobs['user_data'] = json.dumps(user_data)
api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', api)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results(job)[0]
self.assertEqual(experiment_result.data.counts['0x1'], 60)
self.assertEqual(experiment_result.data.counts['0x3'], 40)
self.assertEqual(experiment_result.data.probabilities['0x1'], 0.6)
self.assertEqual(experiment_result.data.probabilities['0x3'], 0.4)
self.assertEqual(len(experiment_result.data.memory), 100)
self.assertEqual(experiment_result.data.memory.count('0x1'), 60)
self.assertEqual(experiment_result.data.memory.count('0x3'), 40)
self.assertEqual(experiment_result.name, 'circuit0')
self.assertEqual(experiment_result.shots, number_of_shots)
def test_get_experiment_results_raises_simulation_error_when_no_histogram(self):
api = Mock()
api.get_jobs_from_project.return_value = [{'id': 42, 'results': '{}'}]
api.get_result_from_job.return_value = {'histogram': [], 'raw_text': 'Error'}
job = Mock()
job.job_id.return_value = '42'
simulator = QuantumInspireBackend(api, Mock())
with self.assertRaises(QisKitBackendError) as error:
simulator.get_experiment_results(job)
self.assertEqual(('Result from backend contains no histogram data!\nError',), error.exception.args)
def test_validate_shot_count_zero(self):
simulator = QuantumInspireBackend(Mock(), Mock())
job_dict = self._basic_qobj_dictionary
job_dict['config'][
'shots'] = 1 # first set shots to 1 to satisfy qiskit model validation
job = qiskit.qobj.QasmQobj.from_dict(
job_dict) # qiskit validation is satisfied
job.config.shots = 0 # now set the number of shots to 0 to trigger our validation
self.assertRaisesRegex(QisKitBackendError,
"Invalid shots \(number_of_shots=0\)",
simulator.run, job)
def _generate_cqasm_from_instructions(instructions, number_of_qubits=2):
experiment_dict = {'instructions': instructions,
'header': {'n_qubits': number_of_qubits,
'number_of_clbits': number_of_qubits,
'compiled_circuit_qasm': ''},
'config': {'coupling_map': 'all-to-all',
'basis_gates': 'x,y,z,h,rx,ry,rz,s,cx,ccx,u1,u2,u3,id,snapshot',
'n_qubits': number_of_qubits}}
experiment = qiskit.qobj.QobjExperiment.from_dict(experiment_dict)
simulator = QuantumInspireBackend(Mock(), Mock())
result = simulator._generate_cqasm(experiment)
return result
def test_validate_no_classical_qubits(self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
simulator = QuantumInspireBackend(api, Mock())
job_dict = self._basic_qobj_dictionary
job_dict['experiments'][0]['instructions'] = []
job_dict['experiments'][0]['header']['memory_slots'] = 0
job = qiskit.qobj.Qobj.from_dict(job_dict)
self.assertRaisesRegex(QisKitBackendError,
'Invalid amount of classical bits \(0\)!',
simulator.run, job)
def test_validate_shot_count(self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {'max_number_of_shots': 4096}
simulator = QuantumInspireBackend(api, Mock())
job_dict = self._basic_qobj_dictionary
job_dict['config']['shots'] = 1 # first set shots to 1 to satisfy qiskit model validation
job = qiskit.qobj.QasmQobj.from_dict(job_dict) # qiskit validation is satisfied
job.config.shots = 0 # now set the number of shots to 0 to trigger our validation
self.assertRaisesRegex(QisKitBackendError, "Invalid shots \(number_of_shots=0\)", simulator.run, job)
job.config.shots = 4097 # now set the number of shots to a too high value
self.assertRaisesRegex(QisKitBackendError, "Invalid shots \(number_of_shots=4097\)", simulator.run, job)
def test_run_returns_correct_result(self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.get_jobs_from_project.return_value = []
api.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {'max_number_of_shots': 4096}
simulator = QuantumInspireBackend(api, Mock())
instructions = [{'name': 'cx', 'qubits': [0, 1], 'memory': [0, 1]},
{'name': 'measure', 'qubits': [0], 'memory': [1]}]
qobj_dict = self._basic_qobj_dictionary
qobj_dict['experiments'][0]['instructions'] = instructions
qobj = QasmQobj.from_dict(qobj_dict)
job = simulator.run(qobj)
self.assertEqual('42', job.job_id())
