def load_unroll_qasm_file(filename, basis_gates='u1,u2,u3,cx,id'): """Load qasm file and return unrolled circuit Args: filename (str): a string for the filename including its location. basis_gates (str): basis to unroll circuit to. Returns: Returns a unrolled QuantumCircuit object """ # create Program object Node (AST) program_node_circuit = qasm.Qasm(filename=filename).parse() unrolled_circuit = unroll.Unroller( program_node_circuit, unroll.CircuitBackend(basis_gates.split(","))) circuit_unrolled = unrolled_circuit.execute() return circuit_unrolled
def setup(self, n_qubits, depth): seed = 42 # NOTE: Remove the benchmarks larger than 20x2048 and 14x8192, this is # a tradeoff for speed of benchmarking, creating circuits this size # takes more time than is worth it for benchmarks that take a couple # seconds if n_qubits >= 20: if depth >= 2048: raise NotImplementedError elif n_qubits == 14: if depth > 2048: raise NotImplementedError self.qc = random_circuit(n_qubits, depth, measure=True, conditional=True, seed=seed) self.dag = converters.circuit_to_dag(self.qc) self.qasm = qasm.Qasm(data=self.qc.qasm()).parse()
def __init__(self, compiled_circuit): """Initial the UnitarySimulator object.""" basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=compiled_circuit).parse(), unroll.SimulatorBackend(basis_gates)) unroller.backend.set_trace(False) unroller.execute() self.circuit = unroller.backend.circuit self._number_of_qubits = self.circuit['number_of_qubits'] self.result = {} self.result = {} self.result['data'] = {} self._unitary_state = np.identity(2**(self._number_of_qubits), dtype=complex) self._number_of_operations = self.circuit['number_of_operations']
def parse(file_path, verbose=False, prec=15): """ - file_path: Path to the OpenQASM file - prec: Precision for the returned string """ qiskit_qasm = qasm.Qasm(file_path) try: qiskit_qasm.parse().qasm(prec) return True except qasm.QasmError as err: if verbose: print("Error:") print(err) return False
def test_unitary_simulator(self): """test generation of circuit unitary""" shots = 1024 self.qp.load_qasm_file(self.qasmFileName, name='example') basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=self.qp.get_qasm('example')).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() #strip measurements from circuit to avoid warnings circuit['operations'] = [ op for op in circuit['operations'] if op['name'] != 'measure' ] # the simulator is expecting a JSON format, so we need to convert it back to JSON qobj = { 'id': 'unitary', 'config': { 'max_credits': None, 'shots': 1, 'backend': 'local_unitary_simulator' }, 'circuits': [{ 'name': 'test', 'compiled_circuit': circuit, 'compiled_circuit_qasm': self.qp.get_qasm('example'), 'config': { 'coupling_map': None, 'basis_gates': None, 'layout': None, 'seed': None } }] } # numpy.savetxt currently prints complex numbers in a way # loadtxt can't read. To save file do, # fmtstr=['% .4g%+.4gj' for i in range(numCols)] # np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, delimiter=',') expected = np.loadtxt( self._get_resource_path('example_unitary_matrix.dat'), dtype='complex', delimiter=',') result = UnitarySimulator(qobj).run() self.assertTrue( np.allclose(result.get_data('test')['unitary'], expected, rtol=1e-3))
def test_unitary_simulator(self): """test generation of circuit unitary""" self.qp.load_qasm_file(self.qasm_filename, name='example') basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=self.qp.get_qasm('example')).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() # strip measurements from circuit to avoid warnings circuit['instructions'] = [ op for op in circuit['instructions'] if op['name'] != 'measure' ] # the simulator is expecting a JSON format, so we need to convert it # back to JSON qobj = { 'id': 'unitary', 'config': { 'max_credits': None, 'shots': 1 }, 'experiments': [circuit], 'header': { 'backend_name': 'local_unitary_simulator_py' } } qobj = Qobj.from_dict(qobj) qobj.experiments[0].header.name = 'test' qobj.experiments[0].header.compiled_circuit_qasm = self.qp.get_qasm( 'example') qobj.experiments[0].config = QobjItem(coupling_map=None, basis_gates=None, layout=None, seed=None) # numpy.savetxt currently prints complex numbers in a way # loadtxt can't read. To save file do, # fmtstr=['% .4g%+.4gj' for i in range(numCols)] # np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, # delimiter=',') expected = np.loadtxt( self._get_resource_path('example_unitary_matrix.dat'), dtype='complex', delimiter=',') result = UnitarySimulatorPy().run(qobj).result() self.assertTrue( np.allclose(result.get_unitary('test'), expected, rtol=1e-3))
def get_circuits(self, format_='dag'): """Get the compiled circuits generated. Args: format_ (str, optional): "qasm" | "qobj" | "QuantumCircuit" Returns: list: List of Compiled QuantumCircuit objects. Raises: NameError: if the output format is not valid. """ if format_ == 'qasm': qasm_list = [] for circuit in self.circuit_list: qasm_list.append(circuit.qasm()) return qasm_list elif format_ == 'qobj': json_list = [] for circuit in self.circuit_list: node_circuit = qasm.Qasm(data=circuit.qasm()).parse() unrolled_circuit = unroll.Unroller( node_circuit, unroll.JsonBackend(self.basis_gates)) json_list.append(unrolled_circuit.execute()) return json_list elif format_ == 'QuantumCircuit': qc_list = [] for circuit in self.circuit_list: qc_list.append(circuit) # node_circuit = qasm.Qasm(data=circuit.qasm()).parse() # unrolled_circuit = unroll.Unroller( # node_circuit, # unroll.CircuitBackend(self.basis_gates)) # qc_list.append(unrolled_circuit.execute()) return qc_list # elif format is 'dag': # qc_list = [] # for circuit in self.circuit_list: # node_circuit = qasm.Qasm(data=circuit.qasm()).parse() # unrolled_circuit = unroll.Unroller( # node_circuit, # unroll.DAGBackend(self.basis_gates)) # qc_list.append(unrolled_circuit.execute()) # return qc_list else: raise NameError( 'Unrecognized circuit output format: "{}"'.format(format_))
def compiler_function(dag_circuit, coupling_map=None, gate_costs=None): """ Modify a DAGCircuit based on a gate cost function. Instructions: Your submission involves filling in the implementation of this function. The function takes as input a DAGCircuit object, which can be generated from a QASM file by using the function 'qasm_to_dag_circuit' from the included 'submission_evaluation.py' module. For more information on the DAGCircuit object see the or QISKit documentation (eg. 'help(DAGCircuit)'). Args: dag_circuit (DAGCircuit): DAGCircuit object to be compiled. coupling_circuit (list): Coupling map for device topology. A coupling map of None corresponds an all-to-all connected topology. gate_costs (dict) : dictionary of gate names and costs. Returns: A modified DAGCircuit object that satisfies an input coupling_map and has as low a gate_cost as possible. """ # I only modified the swap mapper coupling = Coupling(coupling_map) # Add swaps, so that we only use cnots that are allowed by the coupling map compiled_dag = my_swap_mapper(deepcopy(dag_circuit), coupling, speedup=False) # Expand swaps basis_gates = "u1,u2,u3,cx,id" # QE target basis program_node_circuit = qasm.Qasm(data=compiled_dag.qasm()).parse() unroller_circuit = unroll.Unroller( program_node_circuit, unroll.DAGBackend(basis_gates.split(","))) compiled_dag = unroller_circuit.execute() # Change cx directions compiled_dag = direction_mapper(compiled_dag, coupling) # Simplify cx gates cx_cancellation(compiled_dag) # Simplify single qubit gates compiled_dag = optimize_1q_gates(compiled_dag) # Return the compiled dag circuit return compiled_dag
def setUp(self): self.qp = None self.seed = 88 qasm_filename = self._get_resource_path('qasm/example.qasm') unroller = unroll.Unroller( qasm.Qasm(filename=qasm_filename).parse(), unroll.JsonBackend([])) circuit = QobjExperiment.from_dict(unroller.execute()) circuit.config = QobjItem(coupling_map=None, basis_gates='u1,u2,u3,cx,id', layout=None, seed=self.seed) circuit.header.name = 'test' self.qobj = Qobj( id='test_sim_single_shot', config=QobjConfig(shots=1024, memory_slots=6, max_credits=3), experiments=[circuit], header=QobjHeader(backend_name='local_qasm_simulator_py'))
def __init__(self, compiled_circuit, shots, seed=random.random()): """Initialize the QasmSimulator object.""" basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=compiled_circuit).parse(), unroll.SimulatorBackend(basis_gates)) unroller.backend.set_trace(False) unroller.execute() self.circuit = unroller.backend.circuit self._number_of_qubits = self.circuit['number_of_qubits'] self._number_of_cbits = self.circuit['number_of_cbits'] self.result = {} self.result['data'] = {} self._quantum_state = 0 self._classical_state = 0 self._shots = shots random.seed(seed) self._number_of_operations = self.circuit['number_of_operations']
def setUp(self): self.seed = 88 self.qasmFileName = os.path.join(qiskit.__path__[0], '../test/python/qasm/example.qasm') self.qp = QuantumProgram() shots = 1 self.qp.load_qasm_file(self.qasmFileName, name='example') basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=self.qp.get_qasm("example")).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() self.job = { 'compiled_circuit': circuit, 'config': { 'shots': shots, 'seed': random.randint(0, 10) } }
def _unroller_code(qasm_circuit, basis_gates=None): """ Unroll the code. Circuit is the circuit to unroll using the DAG representation. This is an internal function. Args: qasm_circuit (str): a circuit representation as qasm text. basis_gates (str): a comma seperated string and are the base gates, which by default are: u1,u2,u3,cx,id Return: object: a dag representation of the circuit unrolled to basis gates """ if not basis_gates: basis_gates = "u1,u2,u3,cx,id" # QE target basis program_node_circuit = qasm.Qasm(data=qasm_circuit).parse() unroller_circuit = unroll.Unroller( program_node_circuit, unroll.DAGBackend(basis_gates.split(","))) dag_circuit_unrolled = unroller_circuit.execute() return dag_circuit_unrolled
def test_dag_to_dag_expand_gates_custom_basis(self): """Test DagUnroller.expand_gates() to a gate basis.""" ast = qasm.Qasm( filename=self._get_resource_path('qasm/example.qasm')).parse() dag_circuit = Unroller(ast, DAGBackend()).execute() dag_unroller = DagUnroller(dag_circuit, DAGBackend()) expanded_dag_circuit = dag_unroller.expand_gates( basis=["cx", "u1", "u2", "u3"]) expected_result = """\ OPENQASM 2.0; qreg q[3]; qreg r[3]; creg c[3]; creg d[3]; gate u2(phi,lambda) q { U((pi/2),phi,lambda) q; } gate h a { u2(0,pi) a; } gate cx c,t { CX c,t; } u2(0,pi) q[2]; cx q[2],r[2]; measure r[2] -> d[2]; u2(0,pi) q[1]; cx q[1],r[1]; measure r[1] -> d[1]; u2(0,pi) q[0]; cx q[0],r[0]; barrier q[0],q[1],q[2]; measure q[0] -> c[0]; measure q[1] -> c[1]; measure q[2] -> c[2]; measure r[0] -> d[0]; """ self.assertEqual(expanded_dag_circuit.qasm(), expected_result)
def setUp(self): self.seed = 88 self.qasm_filename = self._get_resource_path('qasm/example.qasm') with open(self.qasm_filename, 'r') as qasm_file: self.qasm_text = qasm_file.read() self.qasm_ast = qasm.Qasm(data=self.qasm_text).parse() self.qasm_be = unroll.CircuitBackend( ['u1', 'u2', 'u3', 'id', 'cx']) self.qasm_circ = unroll.Unroller(self.qasm_ast, self.qasm_be).execute() qr = QuantumRegister(2, 'q') cr = ClassicalRegister(2, 'c') qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = QobjExperiment.from_dict( transpile_dag(DAGCircuit.fromQuantumCircuit(self.qc), format='json')) compiled_circuit2 = QobjExperiment.from_dict( transpile_dag(DAGCircuit.fromQuantumCircuit(self.qasm_circ), format='json')) self.qobj = Qobj(qobj_id='test_qobj', config=QobjConfig(shots=2000, memory_slots=1, max_credits=3, seed=1111), experiments=[compiled_circuit1, compiled_circuit2], header=QobjHeader(backend_name='qasm_simulator')) self.qobj.experiments[0].header.name = 'test_circuit1' self.qobj.experiments[0].config = QobjItem( basis_gates='u1,u2,u3,cx,id') self.qobj.experiments[1].header.name = 'test_circuit2' self.qobj.experiments[1].config = QobjItem( basis_gates='u1,u2,u3,cx,id') self.backend = QasmSimulator()
def setUp(self): self.seed = 88 self.qasm_filename = self._get_resource_path('qasm/example.qasm') self.qp = QuantumProgram() self.qp.load_qasm_file(self.qasm_filename, name='example') basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=self.qp.get_qasm('example')).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() circuit_config = { 'coupling_map': None, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': self.seed } resources = {'max_credits': 3} self.qobj = { 'id': 'test_sim_single_shot', 'config': { 'max_credits': resources['max_credits'], 'shots': 1024, 'backend_name': 'local_qasm_simulator_py', }, 'circuits': [{ 'name': 'test', 'compiled_circuit': circuit, 'compiled_circuit_qasm': None, 'config': circuit_config }] } self.q_job = QuantumJob(self.qobj, backend=QasmSimulatorPy(), circuit_config=circuit_config, seed=self.seed, resources=resources, preformatted=True)
def test_if_statement(self): logging.info('test_if_statement_x') shots = 100 max_qubits = 3 qp = QuantumProgram() qr = qp.create_quantum_register('qr', max_qubits) cr = qp.create_classical_register('cr', max_qubits) circuit = qp.create_circuit('test_if', [qr], [cr]) circuit.x(qr[0]) circuit.x(qr[1]) circuit.measure(qr[0], cr[0]) circuit.measure(qr[1], cr[1]) circuit.x(qr[2]).c_if(cr, 0x3) circuit.measure(qr[0], cr[0]) circuit.measure(qr[1], cr[1]) circuit.measure(qr[2], cr[2]) basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=qp.get_qasm('test_if')).parse(), unroll.JsonBackend(basis_gates)) ucircuit = json.loads(unroller.execute()) config = {'shots': shots, 'seed': self.seed} job = {'compiled_circuit': json.dumps(ucircuit), 'config': config} result_if_true = QasmSimulator(job).run() del ucircuit['operations'][1] # remove x(qr[1]) operation job = {'compiled_circuit': json.dumps(ucircuit), 'config': config} result_if_false = QasmSimulator(job).run() logging.info('result_if_true circuit:') logging.info(circuit.qasm()) logging.info('result_if_true={0}'.format(result_if_true)) del circuit.data[1] logging.info('result_if_false circuit:') logging.info(circuit.qasm()) logging.info('result_if_false={0}'.format(result_if_false)) self.assertTrue(result_if_true['data']['counts']['111'] == 100) self.assertTrue(result_if_false['data']['counts']['001'] == 100)
def test_qasm_simulator(self): """Test data counts output for single circuit run against reference.""" shots = 1024 self.qp.load_qasm_file(self.qasmFileName, name='example') basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=self.qp.get_qasm("example")).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() config = {'shots': shots, 'seed': self.seed} job = {'compiled_circuit': circuit, 'config': config} result = QasmSimulator(job).run() expected = { '100 100': 137, '011 011': 131, '101 101': 117, '111 111': 127, '000 000': 131, '010 010': 141, '110 110': 116, '001 001': 124 } self.assertEqual(result['data']['counts'], expected)
def dag2json(dag_circuit, basis_gates='u1,u2,u3,cx,id'): """Make a Json representation of the circuit. Takes a circuit dag and returns json circuit obj. This is an internal function. Args: dag_ciruit (dag object): a dag representation of the circuit. basis_gates (str): a comma seperated string and are the base gates, which by default are: u1,u2,u3,cx,id Returns: the json version of the dag """ # TODO: Jay: I think this needs to become a method like .qasm() for the DAG. try: circuit_string = dag_circuit.qasm(qeflag=True) except TypeError: circuit_string = dag_circuit.qasm() unroller = unroll.Unroller(qasm.Qasm(data=circuit_string).parse(), unroll.JsonBackend(basis_gates.split(","))) json_circuit = unroller.execute() return json_circuit
def test_if_statement(self): self.log.info('test_if_statement_x') shots = 100 max_qubits = 3 qr = QuantumRegister(max_qubits, 'qr') cr = ClassicalRegister(max_qubits, 'cr') circuit_if_true = QuantumCircuit(qr, cr, name='test_if_true') circuit_if_true.x(qr[0]) circuit_if_true.x(qr[1]) circuit_if_true.measure(qr[0], cr[0]) circuit_if_true.measure(qr[1], cr[1]) circuit_if_true.x(qr[2]).c_if(cr, 0x3) circuit_if_true.measure(qr[0], cr[0]) circuit_if_true.measure(qr[1], cr[1]) circuit_if_true.measure(qr[2], cr[2]) circuit_if_false = QuantumCircuit(qr, cr, name='test_if_false') circuit_if_false.x(qr[0]) circuit_if_false.measure(qr[0], cr[0]) circuit_if_false.measure(qr[1], cr[1]) circuit_if_false.x(qr[2]).c_if(cr, 0x3) circuit_if_false.measure(qr[0], cr[0]) circuit_if_false.measure(qr[1], cr[1]) circuit_if_false.measure(qr[2], cr[2]) basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=circuit_if_true.qasm()).parse(), unroll.JsonBackend(basis_gates)) ucircuit_true = QobjExperiment.from_dict(unroller.execute()) unroller = unroll.Unroller( qasm.Qasm(data=circuit_if_false.qasm()).parse(), unroll.JsonBackend(basis_gates)) ucircuit_false = QobjExperiment.from_dict(unroller.execute()) # Customize the experiments and create the qobj. ucircuit_true.config = QobjItem(coupling_map=None, basis_gates='u1,u2,u3,cx,id', layout=None, seed=None) ucircuit_true.header.name = 'test_if_true' ucircuit_false.config = QobjItem(coupling_map=None, basis_gates='u1,u2,u3,cx,id', layout=None, seed=None) ucircuit_false.header.name = 'test_if_false' qobj = Qobj(id='test_if_qobj', config=QobjConfig(max_credits=3, shots=shots, memory_slots=max_qubits), experiments=[ucircuit_true, ucircuit_false], header=QobjHeader(backend_name='local_qasm_simulator_py')) result = QasmSimulatorPy().run(qobj).result() result_if_true = result.get_data('test_if_true') self.log.info('result_if_true circuit:') self.log.info(circuit_if_true.qasm()) self.log.info('result_if_true=%s', result_if_true) result_if_false = result.get_data('test_if_false') self.log.info('result_if_false circuit:') self.log.info(circuit_if_false.qasm()) self.log.info('result_if_false=%s', result_if_false) self.assertTrue(result_if_true['counts']['111'] == 100) self.assertTrue(result_if_false['counts']['001'] == 100)
def test_from_dag_to_json_with_basis(self): ast = qasm.Qasm( filename=self._get_resource_path('qasm/example.qasm')).parse() dag_circuit = Unroller(ast, DAGBackend(["cx", "u1", "u2", "u3"])).execute() dag_unroller = DagUnroller(dag_circuit, JsonBackend(["cx", "u1", "u2", "u3"])) json_circuit = dag_unroller.execute() expected_result = { 'operations': [{ 'qubits': [5], 'texparams': ['0', '\\pi'], 'params': [0.0, 3.141592653589793], 'name': 'u2' }, { 'qubits': [5, 2], 'texparams': [], 'params': [], 'name': 'cx' }, { 'qubits': [2], 'clbits': [2], 'name': 'measure' }, { 'qubits': [4], 'texparams': ['0', '\\pi'], 'params': [0.0, 3.141592653589793], 'name': 'u2' }, { 'qubits': [4, 1], 'texparams': [], 'params': [], 'name': 'cx' }, { 'qubits': [1], 'clbits': [1], 'name': 'measure' }, { 'qubits': [3], 'texparams': ['0', '\\pi'], 'params': [0.0, 3.141592653589793], 'name': 'u2' }, { 'qubits': [3, 0], 'texparams': [], 'params': [], 'name': 'cx' }, { 'qubits': [3, 4, 5], 'name': 'barrier' }, { 'qubits': [5], 'clbits': [5], 'name': 'measure' }, { 'qubits': [4], 'clbits': [4], 'name': 'measure' }, { 'qubits': [3], 'clbits': [3], 'name': 'measure' }, { 'qubits': [0], 'clbits': [0], 'name': 'measure' }], 'header': { 'clbit_labels': [['d', 3], ['c', 3]], 'number_of_qubits': 6, 'qubit_labels': [['r', 0], ['r', 1], ['r', 2], ['q', 0], ['q', 1], ['q', 2]], 'number_of_clbits': 6 } } self.assertEqual(json_circuit, expected_result)
def test_from_dag_to_json(self): ast = qasm.Qasm( filename=self._get_resource_path('qasm/example.qasm')).parse() dag_circuit = Unroller(ast, DAGBackend()).execute() dag_unroller = DagUnroller(dag_circuit, JsonBackend()) json_circuit = dag_unroller.execute() expected_result = { 'operations': [{ 'qubits': [5], 'texparams': ['0.5 \\pi', '0', '\\pi'], 'name': 'U', 'params': [1.5707963267948966, 0.0, 3.141592653589793] }, { 'name': 'CX', 'qubits': [5, 2] }, { 'clbits': [2], 'name': 'measure', 'qubits': [2] }, { 'qubits': [4], 'texparams': ['0.5 \\pi', '0', '\\pi'], 'name': 'U', 'params': [1.5707963267948966, 0.0, 3.141592653589793] }, { 'name': 'CX', 'qubits': [4, 1] }, { 'clbits': [1], 'name': 'measure', 'qubits': [1] }, { 'qubits': [3], 'texparams': ['0.5 \\pi', '0', '\\pi'], 'name': 'U', 'params': [1.5707963267948966, 0.0, 3.141592653589793] }, { 'name': 'CX', 'qubits': [3, 0] }, { 'name': 'barrier', 'qubits': [3, 4, 5] }, { 'clbits': [5], 'name': 'measure', 'qubits': [5] }, { 'clbits': [4], 'name': 'measure', 'qubits': [4] }, { 'clbits': [3], 'name': 'measure', 'qubits': [3] }, { 'clbits': [0], 'name': 'measure', 'qubits': [0] }], 'header': { 'number_of_clbits': 6, 'qubit_labels': [['r', 0], ['r', 1], ['r', 2], ['q', 0], ['q', 1], ['q', 2]], 'number_of_qubits': 6, 'clbit_labels': [['d', 3], ['c', 3]] } } self.assertEqual(json_circuit, expected_result)
def test_if_statement(self): self.log.info('test_if_statement_x') shots = 100 max_qubits = 3 qp = QuantumProgram() qr = qp.create_quantum_register('qr', max_qubits) cr = qp.create_classical_register('cr', max_qubits) circuit_if_true = qp.create_circuit('test_if_true', [qr], [cr]) circuit_if_true.x(qr[0]) circuit_if_true.x(qr[1]) circuit_if_true.measure(qr[0], cr[0]) circuit_if_true.measure(qr[1], cr[1]) circuit_if_true.x(qr[2]).c_if(cr, 0x3) circuit_if_true.measure(qr[0], cr[0]) circuit_if_true.measure(qr[1], cr[1]) circuit_if_true.measure(qr[2], cr[2]) circuit_if_false = qp.create_circuit('test_if_false', [qr], [cr]) circuit_if_false.x(qr[0]) circuit_if_false.measure(qr[0], cr[0]) circuit_if_false.measure(qr[1], cr[1]) circuit_if_false.x(qr[2]).c_if(cr, 0x3) circuit_if_false.measure(qr[0], cr[0]) circuit_if_false.measure(qr[1], cr[1]) circuit_if_false.measure(qr[2], cr[2]) basis_gates = [] # unroll to base gates unroller = unroll.Unroller( qasm.Qasm(data=qp.get_qasm('test_if_true')).parse(), unroll.JsonBackend(basis_gates)) ucircuit_true = unroller.execute() unroller = unroll.Unroller( qasm.Qasm(data=qp.get_qasm('test_if_false')).parse(), unroll.JsonBackend(basis_gates)) ucircuit_false = unroller.execute() qobj = { 'id': 'test_if_qobj', 'config': { 'max_credits': 3, 'shots': shots, 'backend_name': 'local_qasm_simulator_py', }, 'circuits': [{ 'name': 'test_if_true', 'compiled_circuit': ucircuit_true, 'compiled_circuit_qasm': None, 'config': { 'coupling_map': None, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None } }, { 'name': 'test_if_false', 'compiled_circuit': ucircuit_false, 'compiled_circuit_qasm': None, 'config': { 'coupling_map': None, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None } }] } q_job = QuantumJob(qobj, backend=QasmSimulatorPy(), preformatted=True) result = QasmSimulatorPy().run(q_job).result() result_if_true = result.get_data('test_if_true') self.log.info('result_if_true circuit:') self.log.info(circuit_if_true.qasm()) self.log.info('result_if_true=%s', result_if_true) result_if_false = result.get_data('test_if_false') self.log.info('result_if_false circuit:') self.log.info(circuit_if_false.qasm()) self.log.info('result_if_false=%s', result_if_false) self.assertTrue(result_if_true['counts']['111'] == 100) self.assertTrue(result_if_false['counts']['001'] == 100)
def compiler_function(dag_circuit, coupling_map=None, gate_costs=None): """ Modify a DAGCircuit based on a gate cost function. Instructions: Your submission involves filling in the implementation of this function. The function takes as input a DAGCircuit object, which can be generated from a QASM file by using the function 'qasm_to_dag_circuit' from the included 'submission_evaluation.py' module. For more information on the DAGCircuit object see the or QISKit documentation (eg. 'help(DAGCircuit)'). Args: dag_circuit (DAGCircuit): DAGCircuit object to be compiled. coupling_circuit (list): Coupling map for device topology. A coupling map of None corresponds an all-to-all connected topology. gate_costs (dict) : dictionary of gate names and costs. Returns: A modified DAGCircuit object that satisfies an input coupling_map and has as low a gate_cost as possible. """ qasm_in = dag_circuit.qasm() Q_program = QuantumProgram() qcircuit_name = Q_program.load_qasm_text(qasm_in) qcircuit = Q_program.get_circuit(qcircuit_name) tuple_map = {} if coupling_map is None: # todo: make all-to-all map raise ValueError else: for key in coupling_map.keys(): tuple_map[key] = tuple(coupling_map[key]) result, cost = Embed(qcircuit, tuple_map) compiled_dag = DAGCircuit.fromQuantumCircuit(result) return compiled_dag if False: # Example using mapper passes in Qiskit import copy from qiskit.mapper import swap_mapper, direction_mapper, cx_cancellation, optimize_1q_gates, Coupling from qiskit import qasm, unroll initial_layout = None coupling = Coupling(coupling_map) compiled_dag, final_layout = swap_mapper(copy.deepcopy(dag_circuit), coupling, initial_layout, trials=40, seed=19) # Expand swaps basis_gates = "u1,u2,u3,cx,id" # QE target basis program_node_circuit = qasm.Qasm(data=compiled_dag.qasm()).parse() unroller_circuit = unroll.Unroller( program_node_circuit, unroll.DAGBackend(basis_gates.split(","))) compiled_dag = unroller_circuit.execute() # Change cx directions compiled_dag = direction_mapper(compiled_dag, coupling) # Simplify cx gates cx_cancellation(compiled_dag) # Simplify single qubit gates compiled_dag = optimize_1q_gates(compiled_dag) # Return the compiled dag circuit return compiled_dag