def test_submit_job(self): # Create a valid qpu qpu_valid = SimulatedAnnealing( temp_t=TestSimulatedAnnealing.temp_t_valid, n_steps=TestSimulatedAnnealing.n_steps_valid, seed=8017) # Create an Observable Job and check that such Jobs are not dealt with by the qpu observable = Observable(5) job = Job(observable=observable) with pytest.raises(exceptions_types.QPUException): assert result == qpu_valid.submit_job(job) # Create a circuit Job a and check that such Jobs are not dealt with by the qpu from qat.lang.AQASM import Program, H prog = Program() reg = prog.qalloc(1) prog.apply(H, reg) prog.reset(reg) with pytest.raises(exceptions_types.QPUException): assert result == qpu_valid.submit(prog.to_circ().to_job(nbshots=1)) # Create a Job from a Schedule with empty drive and check that such # Jobs are not dealt with by the qpu schedule = Schedule() job = Job(schedule=schedule) with pytest.raises(exceptions_types.QPUException): assert result == qpu_valid.submit_job(job) # Create a job from a Schedule with a drive with more than one observable # or an observable with coefficient not 1 to check that such Jobs don't work # with the qpu observable = get_observable(TestSimulatedAnnealing.J_valid, TestSimulatedAnnealing.h_valid, TestSimulatedAnnealing.offset_valid) drive_invalid_1 = [(1, observable), (1, observable)] schedule = Schedule(drive=drive_invalid_1) job = schedule.to_job() with pytest.raises(exceptions_types.QPUException): assert result == qpu_valid.submit_job(job) drive_invalid_2 = [(5, observable)] schedule = Schedule(drive=drive_invalid_2) job = schedule.to_job() with pytest.raises(exceptions_types.QPUException): assert result == qpu_valid.submit_job(job) # Solve the problem and check that the returned result is Result result = qpu_valid.submit_job(TestSimulatedAnnealing.job_valid) assert isinstance(result, Result)
def test_reset(self): """test that reset gate works FIXME in 'analyze' mode, not testing intermediate_measurements FIXME not testing if resetting several qbits """ # program with final state: qbit 0 : 0 with 100% prob, # but intermediate measure can be 0 or 1 with 50% prob prog = Program() reg = prog.qalloc(1) prog.apply(H, reg) prog.reset(reg) circ = prog.to_circ() ref_task = Task(circ, get_pylinalg_qpu()) for res in ref_task.execute(nb_samples=5): self.assertEqual(res.state.int, 0) self.assertAlmostEqual( res.intermediate_measurements[0].probability, 0.5, delta=1e-10)
def test_reset(): """ Check the reset gate """ # Define a program prog = Program() qbits = prog.qalloc(2) prog.apply(X, qbits[0]) prog.reset(qbits) circ = prog.to_circ() # Submit circuit result = PyLinalg().submit(circ.to_job()) # Check result assert len(result) == 1 sample = result.raw_data[0] assert sample.state.int == 0 # Check intermediate measurements assert len(sample.intermediate_measurements) == 1 print(sample.intermediate_measurements) assert sample.intermediate_measurements[0].cbits == [True, False]
def qiskit_to_qlm(qiskit_circuit, sep_measures=False, **kwargs): """ Converts a Qiskit circuit into a QLM circuit. Args: qiskit_circuit: The Qiskit circuit to convert sep_measures: Separates measures from the circuit: - if set to :code:`True`, measures won't be included in the resulting circuit, qubits to be measured will be put in a list, the resulting measureless circuit and this list will be returned in a tuple: (resulting_circuit, list_qubits) - if set to :code:`False`, measures will be converted normally (Default, set to False) kwargs: These are the options that you would use on a regular to_circ function, to generate a QLM circuit from a PyAQASM program these are added for more flexibility, for advanced users Returns: :code:`tuple` or :class:`~qat.core.Circuit`: If :code:`sep_measures` is set to: - :code:`True`: the result is a tuple composed of a :class:`~qat.core.Circuit` and a list of qubits that should be measured - :code:`False`: the result is a :class:`~qat.core.Circuit` """ prog = Program() qbits_num = 0 to_measure = [] for reg in qiskit_circuit.qregs: qbits_num = qbits_num + reg.size qbits = prog.qalloc(qbits_num) cbits_num = 0 for reg in qiskit_circuit.cregs: cbits_num = cbits_num + reg.size cbits = prog.calloc(cbits_num) variables = [] for gate_op in qiskit_circuit.data: if gate_op[0].name in ("barrier", "opaque"): continue qbit_args = [] cbit_args = [] prms = [] # gate parameters # Get qbit arguments for qarg in gate_op[1]: qbit_args.append( _get_qindex(qiskit_circuit, qarg.register.name, qarg.index)) # Get cbit arguments for carg in gate_op[2]: cbit_args.append( _get_cindex(qiskit_circuit, carg.register.name, carg.index)) # Get parameters for param in gate_op[0].params: if isinstance(param, (Parameter, ParameterExpression)): prms.append(_qiskit_to_qlm_param(prog, variables, param)) else: prms.append(float(param)) # Apply measure # if gate_op[0].name == "measure": if sep_measures: to_measure.extend(qbit_args) else: prog.measure([qbits[i] for i in qbit_args], [cbits[i] for i in cbit_args]) elif gate_op[0].name == "reset": prog.reset([qbits[i] for i in qbit_args], [cbits[i] for i in cbit_args]) else: if gate_op[0].name == "ms": # In this case, the process function needs the number of qubits prms.append(len(qbit_args)) # Apply gates # num_ctrl_qubits = None try: num_ctrl_qubits = gate_op[0].num_ctrl_qubits except AttributeError: pass gate = get_gate(gate_op[0].name, prms, num_ctrl_qubits) prog.apply(gate, *[qbits[i] for i in qbit_args][:gate.arity]) if sep_measures: return prog.to_circ(**kwargs), list(set(to_measure)) return prog.to_circ(**kwargs)