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 = 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]) circuit2 = qp.create_circuit('test_if_case_2', [qr], [cr]) circuit2.x(qr[0]) circuit2.measure(qr[0], cr[0]) circuit2.measure(qr[1], cr[1]) circuit2.x(qr[2]).c_if(cr, 0x3) circuit2.measure(qr[0], cr[0]) circuit2.measure(qr[1], cr[1]) circuit2.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 = unroller.execute() unroller = unroll.Unroller( qasm.Qasm(data=qp.get_qasm('test_if_case_2')).parse(), unroll.JsonBackend(basis_gates)) ucircuit2 = unroller.execute() config = {'shots': shots, 'seed': self.seed} job = {'compiled_circuit': ucircuit, 'config': config} result_if_true = QasmSimulator(job).run() job = {'compiled_circuit': ucircuit2, 'config': config} result_if_false = QasmSimulator(job).run() self.log.info('result_if_true circuit:') self.log.info(circuit.qasm()) self.log.info('result_if_true={0}'.format(result_if_true)) del circuit.data[1] self.log.info('result_if_false circuit:') self.log.info(circuit.qasm()) self.log.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 get_circuits(self, format='dag'): """Get the compiled circuits generated. Args: format (str, optional): "qasm" | "json" | "QuantumCircuit" Returns: List of Compiled QuantumCircuit objects. """ if format is 'qasm': qasm_list = [] for circuit in self.circuit_list: qasm_list.append(circuit.qasm()) return qasm_list elif format is 'json': 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().decode()) return json_list elif format is 'QuantumCircuit': qc_list = [] for circuit in self.circuit_list: 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
def setUp(self): self.qasm_filename = self._get_resource_path('qasm/simple.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 } resources = {'max_credits': 3, 'wait': 5, 'timeout': 120} self.qobj = { 'id': 'test_sim_single_shot', 'config': { 'max_credits': resources['max_credits'], 'shots': 1024, 'backend_name': 'local_statevector_simulator_sympy', }, 'circuits': [{ 'name': 'test', 'compiled_circuit': circuit, 'compiled_circuit_qasm': None, 'config': circuit_config }] } self.q_job = QuantumJob(self.qobj, backend=StatevectorSimulatorSympy(), circuit_config=circuit_config, resources=resources, preformatted=True)
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, }, 'experiments': [circuit], 'header': {'backend_name': 'local_qasm_simulator_py'}} self.qobj = Qobj.from_dict(self.qobj) self.qobj.experiments[0].config = QobjItem.from_dict(circuit_config) self.qobj.experiments[0].header.name = 'test'
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() # if we want to manipulate the circuit, we have to convert it to a dict circuit = json.loads(circuit.decode()) #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 job = {'compiled_circuit': json.dumps(circuit).encode()} # numpy savetxt is 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(os.path.join(self.modulePath, 'example_unitary_matrix.dat'), dtype='complex', delimiter=',') result = UnitarySimulator(job).run() self.assertTrue( np.allclose(result['data']['unitary'], expected, rtol=1e-3))
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_circuit (QuantumCircuit): 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: json: 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() basis_gates = 'u1,u2,u3,cx,id' if basis_gates is None else basis_gates unroller = unroll.Unroller( qasm.Qasm(data=circuit_string).parse(), unroll.JsonBackend(basis_gates.split(","))) json_circuit = unroller.execute() return json_circuit
def setUp(self): self.seed = 88 self.qasmFileName = self._get_resource_path('qasm/example.qasm') self.qp = QuantumProgram() 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.qobj = { 'id': 'test_sim_single_shot', 'config': { 'max_credits': 3, 'shots': 1024, 'backend': 'local_qasm_simulator', }, 'circuits': [{ 'name': 'test', 'compiled_circuit': circuit, 'compiled_circuit_qasm': None, 'config': { 'coupling_map': None, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': self.seed } }] }
def test_unitary_simulator(self): """test generation of circuit unitary""" unroller = unroll.Unroller( qasm.Qasm(filename=self.qasm_filename).parse(), unroll.JsonBackend([])) circuit = unroller.execute() # strip measurements from circuit to avoid warnings circuit['instructions'] = [ op for op in circuit['instructions'] if op['name'] != 'measure' ] circuit = QobjExperiment.from_dict(circuit) circuit.config = QobjItem(coupling_map=None, basis_gates=None, layout=None, seed=self.seed) circuit.header.name = 'test' qobj = Qobj( id='unitary', config=QobjConfig(shots=1, register_slots=6, max_credits=None), experiments=[circuit], header=QobjHeader(backend_name='local_unitary_simulator_py')) # 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 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['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_name': 'local_sympy_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 } }] } q_job = QuantumJob(qobj, backend=UnitarySimulatorSympy(), preformatted=True) result = UnitarySimulatorSympy().run(q_job).result() actual = result.get_data('test')['unitary'] self.assertEqual(actual[0][0], sqrt(2) / 2) self.assertEqual(actual[0][1], sqrt(2) / 2) self.assertEqual(actual[0][2], 0) self.assertEqual(actual[0][3], 0) self.assertEqual(actual[1][0], 0) self.assertEqual(actual[1][1], 0) self.assertEqual(actual[1][2], sqrt(2) / 2) self.assertEqual(actual[1][3], -sqrt(2) / 2) self.assertEqual(actual[2][0], 0) self.assertEqual(actual[2][1], 0) self.assertEqual(actual[2][2], sqrt(2) / 2) self.assertEqual(actual[2][3], sqrt(2) / 2) self.assertEqual(actual[3][0], sqrt(2) / 2) self.assertEqual(actual[3][1], -sqrt(2) / 2) self.assertEqual(actual[3][2], 0) self.assertEqual(actual[3][3], 0)
def test_json_output(self): qprogram = QuantumProgram() qprogram.load_qasm_file(self.qasm_file_path, name="example") basis_gates = [] # unroll to base gates, change to test unroller = unroll.Unroller(qasm.Qasm(data=qprogram.get_qasm("example")).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() self.log.info('test_json_ouptut: %s', circuit)
def test_json_output(self): seed = 88 qp = QuantumProgram() qp.load_qasm_file(self.QASM_FILE_PATH, name="example") basis_gates = [] # unroll to base gates, change to test unroller = unroll.Unroller( qasm.Qasm(data=qp.get_qasm("example")).parse(), unroll.JsonBackend(basis_gates)) circuit = unroller.execute() logging.info('test_json_ouptut: {0}'.format(circuit))
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['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=',') q_job = QuantumJob(qobj, backend='local_unitary_simulator', preformatted=True) result = UnitarySimulator().run(q_job) self.assertTrue( np.allclose(result.get_data('test')['unitary'], expected, rtol=1e-3))
def test_qasm_simulator_single_shot(self): """Test single shot run.""" 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() config = {'shots': shots, 'seed': self.seed} job = {'compiled_circuit': circuit, 'config': config} result = QasmSimulator(job).run() self.assertEqual(result['status'], 'DONE')
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: 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 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 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 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 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_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)