def test_retrieve_job(self):
api = Mock()
api.get_jobs_from_project.return_value = []
backend = QuantumInspireBackend(api, QuantumInspireProvider())
qi_job = backend.retrieve_job('42')
api.get_project.assert_called_with(42)
self.assertEqual('42', qi_job.job_id())
def test_generate_cqasm_with_entangle_algorithm(self):
q = QuantumRegister(2)
b = ClassicalRegister(2)
circuit = QuantumCircuit(q, b)
circuit.h(q[0])
circuit.cx(q[0], q[1])
circuit.measure(q[0], b[0])
circuit.measure(q[1], b[1])
backend = QuantumInspireBackend(Mock(), Mock())
# transpiling the circuits using the transpiler_config
new_circuits = transpile(circuit, backend)
run_config = RunConfig(shots=1024, max_credits=10, memory=False)
# assembling the circuits into a qobj to be run on the backend
qiskit_job = assemble(new_circuits, backend, run_config=run_config)
experiment = qiskit_job.experiments[0]
result = backend._generate_cqasm(experiment)
expected = "version 1.0\n" \
"# cQASM generated by QI backend for Qiskit\n" \
"qubits 2\n" \
"H q[0]\n" \
"CNOT q[0], q[1]\n"
self.assertEqual(result, expected)
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_run_returns_correct_result_for_my_project_number(self):
default_project_number = 42
my_project_number = 43
api = Mock()
api.create_project.return_value = {'id': default_project_number}
quantum_inspire_job = Mock()
quantum_inspire_job.get_project_identifier.return_value = my_project_number
api.execute_qasm_async.return_value = quantum_inspire_job
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
q = QuantumRegister(3, "q")
c1 = ClassicalRegister(2, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c1, c2, name="test")
qc.h(q[0])
qc.h(q[2])
qc.measure(q[1], c1[0])
qc.measure(q[0], c1[1])
qc.h(q[1]).c_if(c1, 2)
qc.measure(q[0], c1[1])
qc.measure(q[1], c1[0])
job = simulator.run(qc)
api.delete_project.assert_called_with(default_project_number)
self.assertEqual(my_project_number, int(job.job_id()))
def test_for_non_fsp_measurements_at_begin_and_end(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.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
qc = QuantumCircuit(2, 2)
qc.measure(0, 0)
qc.cx(0, 1)
qc.x(0)
qc.measure(1, 1)
simulator.run(qc, 25)
experiment = self._circuit_to_experiment(qc)
result_experiment.assert_called_once_with(experiment,
25,
project=project,
full_state_projection=False)
def test_valid_non_fsp_measurement_qubit_to_classical(self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.get_asset_from_job.return_value = {'project_id': '42'}
quantum_inspire_job = Mock()
quantum_inspire_job.get_project_identifier.return_value = 42
api.execute_qasm_async.return_value = quantum_inspire_job
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
q = QuantumRegister(3, "q")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c1, c2, name="test")
qc.h(0)
qc.h(2)
qc.measure(1, 0)
qc.measure(0, 1)
qc.h(1).c_if(c2, 1)
qc.measure(0, 1)
qc.measure(1, 0)
job = simulator.run(qc)
self.assertEqual('42', job.job_id())
def test_for_non_fsp_hardware_backend(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.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
config = QuantumInspireBackend.DEFAULT_CONFIGURATION
config.backend_name = 'qi_hardware'
config.simulator = False
simulator = QuantumInspireBackend(api, config)
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.x(0)
simulator.run(qc, 25)
experiment = self._circuit_to_experiment(qc)
result_experiment.assert_called_once_with(experiment,
25,
project=project,
full_state_projection=False)
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_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 _generate_cqasm_from_instructions(instructions,
number_of_qubits=2,
full_state_projection=True):
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.QasmQobjExperiment.from_dict(experiment_dict)
for instruction in experiment.instructions:
if hasattr(instruction, 'params'):
# convert params to params used in qiskit instructions
qiskit_instruction = Instruction('dummy', 0, 0,
instruction.params)
instruction.params = qiskit_instruction.params
simulator = QuantumInspireBackend(Mock(), Mock())
result = simulator._generate_cqasm(experiment, full_state_projection)
return result
def test_get_experiment_results_multiple_single_shots(self):
one_shot_results = {'0x0': 0, '0x1': 0, '0x2': 0, '0x3': 0}
np.random.seed(2019)
for i in range(10000):
number_of_shots = 1
self._basic_job_dictionary['number_of_shots'] = number_of_shots
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
experiment = self._circuit_to_experiment(qc)
api = Mock()
api.get_result_from_job.return_value = {
'id':
1,
'histogram': {
'0': 0.2,
'1': 0.3,
'2': 0.4,
'3': 0.1
},
'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 = []
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_from_all_jobs(
job)[0]
# Exactly one value in memory
self.assertEqual(len(experiment_result.data.memory), 1)
# The only value in memory is the same as the value in the counts histogram.
self.assertEqual(
list(experiment_result.data.counts.keys())[0],
experiment_result.data.memory[0])
one_shot_results[experiment_result.data.memory[0]] += 1
self.assertEqual(one_shot_results['0x0'], 2066)
self.assertEqual(one_shot_results['0x1'], 2947)
self.assertEqual(one_shot_results['0x2'], 4003)
self.assertEqual(one_shot_results['0x3'], 984)
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_get_experiment_results_returns_single_shot(self):
number_of_shots = 1
self._basic_job_dictionary['number_of_shots'] = number_of_shots
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
experiment = self._circuit_to_experiment(qc)
api = Mock()
api.get_result_from_job.return_value = {
'id': 1,
'histogram': {
'0': 0.5,
'3': 0.5
},
'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 = []
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
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_from_all_jobs(
job)[0]
self.assertEqual(experiment_result.data.probabilities['0x0'], 0.5)
self.assertEqual(experiment_result.data.probabilities['0x3'], 0.5)
self.assertTrue(hasattr(experiment_result.data, 'memory'))
# Exactly one value in counts histogram
self.assertEqual(len(experiment_result.data.counts), 1)
# The single value in counts histogram has count 1
self.assertEqual(list(experiment_result.data.counts.values())[0], 1)
# Exactly one value in memory
self.assertEqual(len(experiment_result.data.memory), 1)
# The only value in memory is the same as the value in the counts histogram.
self.assertEqual(
list(experiment_result.data.counts.keys())[0],
experiment_result.data.memory[0])
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 _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_get_experiment_results_returns_correct_value_from_latest_run(
self):
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
number_of_shots = 100
experiment = self._circuit_to_experiment(qc)
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
job = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(experiment)
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
job['user_data'] = json.dumps(user_data)
api.get_job.side_effect = [job]
quantuminspire_job = Mock()
quantuminspire_job.get_job_identifier.side_effect = [1]
qijob = QIJob('backend', '42', api)
qijob.add_job(quantuminspire_job)
simulator = QuantumInspireBackend(api, Mock())
experiment_result = simulator.get_experiment_results_from_latest_run(
qijob)[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_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())
def run_histogram_test(self, single_experiment, mock_result1, mock_result2,
expected_histogram, expected_histogram_prob,
expected_memory):
self.mock_api.set(mock_result1, mock_result2)
jobs = self._basic_job_dictionary
measurements = QuantumInspireBackend._collect_measurements(
QasmQobjExperiment.from_dict(single_experiment))
user_data = {
'name': 'name',
'memory_slots': 2,
'creg_sizes': [['c1', 2]],
'measurements': measurements
}
jobs['user_data'] = json.dumps(user_data)
self.mock_api.get_jobs_from_project.return_value = [jobs]
job = QIJob('backend', '42', self.mock_api)
result = self.simulator.get_experiment_results_from_all_jobs(job)
number_of_shots = jobs['number_of_shots']
self.assertEqual(1, len(result))
first_experiment = first_item(result)
actual = first_experiment.data.counts
self.assertDictEqual(expected_histogram, actual)
probabilities = first_experiment.data.probabilities
self.assertTrue(
len(expected_histogram_prob.keys() - probabilities.keys()) == 0)
for key in set(probabilities.keys()) & set(
expected_histogram_prob.keys()):
self.assertTrue(
np.isclose(expected_histogram_prob[key], probabilities[key]))
self.assertTrue(len(first_experiment.data.memory) == number_of_shots)
self.assertListEqual(expected_memory, first_experiment.data.memory)
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 setUp(self):
self.mock_api = ApiMock(spec=QuantumInspireAPI)
self.mock_provider = Mock(spec=QuantumInspireProvider)
self.simulator = QuantumInspireBackend(self.mock_api,
self.mock_provider)
self._basic_job_dictionary = dict([
('url', 'http://saevar-qutech-nginx/api/jobs/24/'),
('name', 'BLA_BLU'), ('id', 24), ('status', 'COMPLETE'),
('input', 'http://saevar-qutech-nginx/api/assets/26/'),
('backend', 'http://saevar-qutech-nginx/api/backends/1/'),
('backend_type', 'http://saevar-qutech-nginx/api/backendtypes/1/'),
('results', 'http://saevar-qutech-nginx/api/jobs/24/result/'),
('queued_at', '2018-12-07T09:11:45.976617Z'),
('number_of_shots', 1000), ('full_state_projection', True),
('user_data', '')
])
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_validate_NegativeShotCount(self):
simulator = QuantumInspireBackend(Mock(), Mock())
job_dict = self._basic_qobj_dictionary
job_dict['config']['shots'] = 0
job = qiskit.qobj.Qobj.from_dict(job_dict)
self.assertRaises(QisKitBackendError, simulator.run, job)
def test_validate_shot_count(self):
api = Mock()
api.create_project.return_value = {'id': 42}
api.execute_qasm_async.return_value = 42
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
job = self._circuit_to_qobj(qc)
job.config.shots = 0 # 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 backends(self,
name: Optional[str] = None,
**kwargs: Any) -> List[QuantumInspireBackend]:
"""
Provides a list of backends.
Args:
name: Name of the requested backend.
**kwargs: Used for filtering, not implemented.
Returns:
List of backends that meet the filter requirements.
"""
if self._api is None:
raise ApiError('Authentication details have not been set.')
available_backends = self._api.get_backend_types()
if name is not None:
available_backends = list(
filter(lambda b: b['name'] == name, available_backends))
backends = []
for backend in available_backends:
if backend['is_allowed']:
config = copy(QuantumInspireBackend.DEFAULT_CONFIGURATION)
config.backend_name = backend['name']
backends.append(
QuantumInspireBackend(self._api,
provider=self,
configuration=config))
return backends
def test_backend_status(self):
api = Mock()
type(api).__name__ = 'QuantumInspireAPI'
backend_type = {
'max_number_of_shots': 4096,
'status': 'OFFLINE',
'status_message': 'This backend is offline.'
}
api.get_backend_type_by_name.return_value = backend_type
simulator = QuantumInspireBackend(api, Mock())
status = simulator.status()
self.assertEqual(status.backend_name, 'qi_simulator')
self.assertEqual(status.status_msg, backend_type['status_message'])
self.assertEqual(status.backend_version, quantum_inspire_version)
self.assertFalse(status.operational)
self.assertEqual(status.pending_jobs, 0)
def test__collect_measurements(self):
instructions = [{'name': 'cx', 'qubits': [0, 1]},
{'name': 'measure', 'qubits': [0], 'memory': [1]},
{'name': 'measure', 'qubits': [1], 'memory': [0]}]
experiment = self._instructions_to_two_qubit_experiment(instructions)
measurements = QuantumInspireBackend._collect_measurements(experiment)
self.assertDictEqual(measurements, {'measurements': [[1, 0], [0, 1]], 'number_of_clbits': 2})
def test_run_a_circuit_returns_correct_result(self):
api = Mock()
type(api).__name__ = 'QuantumInspireAPI'
api.create_project.return_value = {'id': 42}
api.get_asset_from_job.return_value = {'project_id': '42'}
api.execute_qasm_async.return_value = QuantumInspireJob(api, 42)
api.get_backend_type_by_name.return_value = {
'max_number_of_shots': 4096
}
simulator = QuantumInspireBackend(api, Mock())
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(0, 1)
job = simulator.run(qc, shots=1024)
self.assertEqual('42', job.job_id())
def test_validate_NoClassicalQubits(self):
simulator = QuantumInspireBackend(Mock(), 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.assertRaises(QisKitBackendError, simulator.run, job)
def test_valid_non_fsp_measurement_qubit_to_classical(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 = [{
'name': 'h',
'qubits': [0]
}, {
'name': 'h',
'qubits': [2]
}, {
'memory': [0],
'name': 'measure',
'qubits': [1]
}, {
'memory': [1],
'name': 'measure',
'qubits': [0]
}, {
'mask': '0x2',
'name': 'bfunc',
'register': 7,
'relation': '==',
'val': '0x2'
}, {
'conditional': 7,
'name': 'h',
'qubits': [1]
}, {
'memory': [1],
'name': 'measure',
'qubits': [0]
}, {
'memory': [0],
'name': 'measure',
'qubits': [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())
def test_collect_measurements_without_measurements(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
experiment = self._circuit_to_experiment(qc)
measurements = QuantumInspireBackend._collect_measurements(experiment)
self.assertDictEqual(measurements, {
'measurements': [[0, 0], [1, 1]],
'number_of_clbits': 2
})
