def __init__(self, api: QuantumInspireAPI, provider: Any, configuration: Optional[QasmBackendConfiguration] = None) -> None: """ Python implementation of a quantum simulator using Quantum Inspire API. Args: api: The interface instance to the Quantum Inspire API. provider: Provider for this backend. configuration: The configuration of the quantum inspire backend. The configuration must implement the fields given by the QiSimulatorPy.DEFAULT_CONFIGURATION. All configuration fields are listed in the table below. The table rows with an asterisk specify fields which can have a custom value and are allowed to be changed according to the description column. | key | description |-------------------------|---------------------------------------------------------------------------- | backend_name (str)* | The name of the quantum inspire backend. The API can list the name of each | | available backend using the function api.list_backend_types(). One of the | | listed names must be used. | backend_version (str) | Backend version in the form X.Y.Z. | n_qubits (int) | Number of qubits. | basis_gates (list[str]) | A list of basis gates to compile to. | gates (GateConfig) | List of basis gates on the backend. Not used. | local (bool) | Indicates whether the system is running locally or remotely. Not used. | simulator (bool) | Specifies whether the backend is a simulator or a quantum system. Not used. | conditional (bool) | Backend supports conditional operations. | open_pulse (bool) | Backend supports open pulse. False. | memory (bool) | Backend supports memory. True. | max_shots (int) | Maximum number of shots supported. | max_experiments (int) | Optional: Maximum number of experiments (circuits) per job. """ super().__init__(configuration=(configuration or QuantumInspireBackend.DEFAULT_CONFIGURATION), provider=provider) self.__backend: Dict[str, Any] = api.get_backend_type_by_name(self.name()) self.__api: QuantumInspireAPI = api
def __init__(self, num_runs: int = 1024, verbose: int = 0, quantum_inspire_api: Optional[QuantumInspireAPI] = None, backend_type: Optional[Union[int, str]] = None) -> None: """ Initialize the Backend object. :param num_runs: Number of runs to collect statistics (default is 1024). :param verbose: Verbosity level, defaults to 0, which produces no extra output. :param quantum_inspire_api: Connection to QI platform, optional parameter. :param backend_type: Backend to use for execution. When no backend_type is provided, the default backend will be used. :raises AuthenticationError: When an authentication error occurs. """ BasicEngine.__init__(self) self._flushed: bool = False """ Because engines are meant to be 'single use' by the way ProjectQ is designed, any additional gates received after a FlushGate triggers an exception. """ self._clear: bool = True self._qasm: str = "" self._reset() self._verbose: int = verbose self._cqasm: str = str() self._measured_states: Dict[int, float] = {} self._measured_ids: List[int] = [] self._allocation_map: List[Tuple[int, int]] = [] self._max_qubit_id: int = -1 self._quantum_inspire_result: Dict[str, Any] = {} if quantum_inspire_api is None: try: quantum_inspire_api = QuantumInspireAPI() except AuthenticationError as ex: raise AuthenticationError( 'Make sure you have saved your token credentials on disk or ' 'provide a QuantumInspireAPI instance as parameter to QIBackend' ) from ex self._quantum_inspire_api: QuantumInspireAPI = quantum_inspire_api self._backend_type: Dict[ str, Any] = self._quantum_inspire_api.get_backend_type(backend_type) if num_runs < 1 or num_runs > self._backend_type['max_number_of_shots']: raise ProjectQBackendError( f'Invalid number of runs (num_runs={num_runs})') self._num_runs: int = num_runs self._full_state_projection = not self._backend_type[ "is_hardware_backend"] self._is_simulation_backend = not self._backend_type[ "is_hardware_backend"] self._max_number_of_qubits: int = self._backend_type[ "number_of_qubits"] self._one_qubit_gates: Tuple[Any, ...] = self._get_one_qubit_gates() self._two_qubit_gates: Tuple[Any, ...] = self._get_two_qubit_gates() self._three_qubit_gates: Tuple[Any, ...] = self._get_three_qubit_gates()
def set_authentication(self, authentication: Optional[coreapi.auth.AuthBase] = None, qi_url: str = QI_URL) -> None: """ Initializes the API and sets the authentication for Quantum Inspire. Args: authentication: The authentication, can be one of the following coreapi authentications: BasicAuthentication(email, password), HTTP authentication with valid email/password. TokenAuthentication(token, scheme="token"), token authentication with a valid API-token. When authentication is None, api will try to load a token from the default resource. qi_url: URL that points to quantum-inspire api. Default value: 'https://api.quantum-inspire.com'. """ self._api = QuantumInspireAPI(qi_url, authentication)
def set_authentication(self, authentication: Optional[ coreapi.auth.AuthBase] = None, qi_url: str = QI_URL, project_name: Optional[str] = None) -> None: """ Initializes the API and sets the authentication for Quantum Inspire. :param authentication: The authentication, can be one of the following coreapi authentications: * ``BasicAuthentication(email, password)``, HTTP authentication with valid email/password. * ``TokenAuthentication(token, scheme="token")``, token authentication with a valid API-token. When authentication is ``None``, the api will try to load a token from the default resource. :param qi_url: URL that points to quantum-inspire api. Default value: 'https://api.quantum-inspire.com'. :param project_name: The project name of the project that is used for executing the jobs. """ self._api = QuantumInspireAPI(qi_url, authentication, project_name)
def __init__(self, api: QuantumInspireAPI, provider: Any, configuration: Optional[QasmBackendConfiguration] = None) -> None: """ Python implementation of a quantum simulator using Quantum Inspire API. :param api: The interface instance to the Quantum Inspire API. :param provider: Provider for this backend. :param configuration: The configuration of the Quantum Inspire backend. The configuration must implement the fields given by the QiSimulatorPy.DEFAULT_CONFIGURATION. All configuration fields are listed in the table below. The table rows with an asterisk specify fields which can have a custom value and are allowed to be changed according to the description column. =================== ============= ===================================================================== Key Type Description =================== ============= ===================================================================== ``backend_name`` * str The name of the Quantum Inspire backend. The API can list the name of each available backend using the function api.list_backend_types(). One of the listed names must be used. ``backend_version`` str Backend version in the form X.Y.Z. ``n_qubits`` int Number of qubits. ``basis_gates`` list[str] A list of basis gates to compile to. ``gates`` GateConfig List of basis gates on the backend. Not used. ``local`` bool Indicates whether the system is running locally or remotely. ``simulator`` bool Specifies whether the backend is a simulator or a quantum system. ``conditional`` bool Backend supports conditional operations. ``open_pulse`` bool Backend supports open pulse. False. ``memory`` bool Backend supports memory. True. ``max_shots`` int Maximum number of shots supported. ``max_experiments`` int Optional: Maximum number of experiments (circuits) per job. ``coupling_map`` list[list] Define the edges. =================== ============= ===================================================================== """ super().__init__(configuration=(configuration or QuantumInspireBackend.DEFAULT_CONFIGURATION), provider=provider) self.__backend: Dict[str, Any] = api.get_backend_type_by_name(self.name()) self.__api: QuantumInspireAPI = api
from src.qasm_error_introducer.error_introducer import introduce_error from src.qasm_topology_mapper.mapping import map_to_topology from src.quantum_phase_estimation.processing.classical_postprocessing import print_result, remove_degeneracy from src.quantum_phase_estimation.plot_results import plot_results import numpy as np if __name__ == "__main__": QI_EMAIL = os.getenv('QI_EMAIL') QI_PASSWORD = os.getenv('QI_PASSWORD') QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/') authentication = get_authentication(qi_email=QI_EMAIL, qi_password=QI_PASSWORD, token=load_account()) qi = QuantumInspireAPI(QI_URL, authentication, 'matrix') # variables phase = 0.08 print(phase) unitary_qasm = f"QASM\nRz q[0], {-phase*2*np.pi}" unitary_matrix = np.array([[np.exp(phase * 1j * np.pi), 0], [0, np.exp(-phase * 1j * np.pi)]]) unitary = unitary_matrix custom_prepare = "prep_z q[0]\n X q[0]" desired_bit_accuracy = 5 minimum_chance_of_success = 0.5 mu = 0.5 sigma = 0.5 error_toggle = 0 topology = None
else: if QI_EMAIL is None or QI_PASSWORD is None: print('Enter email:') email = input() print('Enter password') password = getpass() else: email, password = QI_EMAIL, QI_PASSWORD return get_basic_authentication(email, password) if __name__ == '__main__': # Remote Quantum-Inspire backend # authentication = get_authentication() qi = QuantumInspireAPI(r'https://api.quantum-inspire.com/', authentication) compiler_engines = restrictedgateset.get_engine_list( one_qubit_gates="any", two_qubit_gates=(CNOT, CZ, Toffoli)) compiler_engines.extend([ResourceCounter()]) qi_backend = QIBackend(quantum_inspire_api=qi) qi_engine = MainEngine(backend=qi_backend, engine_list=compiler_engines) # Run remote Grover search to find a n-bit solution result_qi = run_grover(qi_engine, 3, alternating_bits_oracle) print("\nResult from the remote Quantum-Inspire backend: {}".format( result_qi)) # Local ProjectQ simulator backend # compiler_engines = restrictedgateset.get_engine_list(one_qubit_gates="any", two_qubit_gates=(CNOT,
def setup_tabs(self): _translate = QtCore.QCoreApplication.translate self.ibm_backends = None self.dwave_backends = None self.inspire_backends = None self.rigetti_backends = None self.tab_infos = [] # backend1 = {'name': '9q-square-noisy-qvm', 'number_of_qubits': 9, # 'max_number_of_shots': 65536, 'max_experiments': 'unlimited', # 'description': 'v. 1.17', 'accuracy': 'not accurate', # 'remaining_jobs': 'unlimited'} # backend2 = {'name': '26q-qvm', 'number_of_qubits': 26, # 'max_number_of_shots': 65536, 'max_experiments': 'unlimited', # 'description': 'v. 1.17', 'accuracy': '0', # 'remaining_jobs': 'unlimited'} # self.rigetti_backends = [backend1, backend2] if self.__qiskit is not None: IBMQ.enable_account(self.__qiskit) ibm_provider = IBMQ.get_provider('ibm-q') self.ibm_backends = ibm_provider.backends() if self.__inspire is not None: enable_account(self.__inspire) QI.set_authentication() server_url = r'https://api.quantum-inspire.com' auth = get_token_authentication() self.qi = QuantumInspireAPI(server_url, auth) # backends = [] # for back in self.qi.get_backend_types(): # current_backend = {'name': back.get('name'), 'number_of_qubits': back.get('number_of_qubits'), # 'max_number_of_shots': back.get('max_number_of_shots'), # 'max_experiments': back.get('max_number_of_simultaneous_jobs'), # 'description': back.get('description'), 'accuracy': 'not measured', # 'remaining_jobs': back.get('max_number_of_simultaneous_jobs')} # backends.append(current_backend) self.inspire_backends = self.qi.get_backend_types() if self.ibm_backends is not None: for backend in self.ibm_backends: self.tab_infos.append(ComputerInfoTab(backend)) # if self.inspire_backends is not None: # for backend in self.inspire_backends: # # server = r'https://api.quantum-inspire.com' # # email = '*****@*****.**' # # password = '******' # # auth = HTTPBasicAuth(email, password) # # # # result = requests.get(f'{server}/projects', auth=auth) # # # # print(f'result status: {result.status_code}') # # print(result.json()) # # server = r'https://api.quantum-inspire.com' # # auth = coreapi.auth.TokenAuthentication(self.__inspire) # # client = coreapi.Client(auth=auth) # # content = client.get(f'{server}/backendtypes/1/calibration') # # print(content) # # action = ['projects', 'list'] # # result = client.action(schema, action) # # print(result) # # server = r'https://api.quantum-inspire.com' # # email = '*****@*****.**' # # password = '******' # # auth = HTTPBasicAuth(email, password) # # contents = urllib.request.urlopen(r'https://api.quantum-inspire.com/backendtypes/1/calibration/',).read() # self.tab_infos.append(ComputerInfoTab(backend._QuantumInspireBackend__backend)) if self.inspire_backends is not None: for backend in self.inspire_backends: self.tab_infos.append(ComputerInfoTab(backend)) if self.rigetti_backends is not None: for backend in self.rigetti_backends: self.tab_infos.append(ComputerInfoTab(backend)) self.tab_widget = QtWidgets.QTabWidget(self.central_widget) self.tab_widget.setObjectName("tabWidget") self.tab_widget.addTab(self.test_info_tab.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(self.test_info_tab.tab), _translate('main_window', self.test_info_tab.name)) self.tab_widget.addTab(self.results_info_tab.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(self.results_info_tab.tab), _translate('main_window', self.results_info_tab.name)) for tab_info in self.tab_infos: self.tab_widget.addTab(tab_info.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(tab_info.tab), _translate("main_window", tab_info.tab.objectName())) self.gridLayout_2.addWidget(self.tab_widget, 0, 0, 1, 1) self.tab_widget.setCurrentIndex(0)
class UiMainWindow(object): __result = None def __init__(self, main_window_local): grover_circuit_constructor = GroverCircuit() shor_circuit_constructor = ShorCircuit() tokens = list(self.get_config().values()) self.__qiskit = tokens[0] self.__dwave = tokens[1] self.__inspire = tokens[2] self.registration_dialog = RegistrationDialogWindow(init=tokens) self.ibm_backends = None self.dwave_backends = None self.inspire_backends = None self.window = main_window_local self.central_widget = QtWidgets.QWidget(main_window_local) self.central_widget.setObjectName("central_widget") self.repo = DataRepository() saved_results = self.repo.get_all() self.thread_pool = QThreadPool() self.thread_pool.setMaxThreadCount(8) self.inner_thread_pool = QThreadPool() self.inner_thread_pool.setMaxThreadCount(8) self.drawer = PlotDrawer() self.writer = FileWriter() self.tab_infos = [] self.default_tests = [] # quantumRegister = q.QuantumRegister(2) # classicalRegister = q.ClassicalRegister(2) # circuit = q.QuantumCircuit(quantumRegister, classicalRegister) # circuit.h(quantumRegister[0]) # circuit.cx(quantumRegister[0], quantumRegister[1]) # circuit.measure(quantumRegister, classicalRegister) # self.default_tests.append(QuantumTest("BellState", circuit, 1024)) shor_answer = 4 grover_2_answer = 3 grover_3_answer = 6 grover_4_answer = 2 grover_5_answer = 21 circuit3 = q.QuantumCircuit(5, 5) shor_circuit_constructor.add_circuit(circuit3) self.default_tests.append( QuantumTest('Shor_3_5', circuit3, 1024, shor_answer)) circuit4 = q.QuantumCircuit(2, 2) grover_circuit_constructor.set_number(grover_2_answer) grover_circuit_constructor.add_circuit(circuit4) self.default_tests.append( QuantumTest('Grover_2_bits', circuit4, 1024, grover_2_answer)) circuit_new = q.QuantumCircuit(3, 3) grover_circuit_constructor.set_number(grover_3_answer) grover_circuit_constructor.add_circuit(circuit_new) self.default_tests.append( QuantumTest('Grover_3_bits', circuit_new, 1024, grover_3_answer)) circuit5 = q.QuantumCircuit(4, 4) grover_circuit_constructor.set_number(grover_4_answer) grover_circuit_constructor.add_circuit(circuit5) self.default_tests.append( QuantumTest('Grover_4_bits', circuit5, 1024, grover_4_answer)) qubits = q.QuantumRegister(5) bits = q.ClassicalRegister(5) # controls = list() # controls.append(qubits[0]) # controls.append(qubits[1]) # controls.append(qubits[2]) circuit6 = q.QuantumCircuit(qubits, bits) grover_circuit_constructor.set_number(grover_5_answer) grover_circuit_constructor.add_circuit(circuit6) self.default_tests.append( QuantumTest('Grover_5_bits', circuit6, 1024, grover_5_answer)) self.test_info_tab = TestInfoTab(self.default_tests, self.drawer) self.results_info_tab = TestResultTab() self.setup_ui(main_window_local) self.setup_tabs() self.dialog = TestCreationDialogWindow(self.tab_infos, self.default_tests) self.dialog.setWindowTitle('Create test') for res in saved_results: self.add_result_from_db(res) def get_config(self): keys = ['qiskit', 'dwave', 'quantum-inspire'] tokens = dict.fromkeys(keys) try: with open('main\\configuration\\config.ini') as config_file: lines = config_file.readlines() for line in lines: api_name = line.strip().split('=')[0] if api_name in keys: tokens[api_name] = line.strip().split('=')[1] except OSError: print('Config file not found') except: print(sys.exc_info()[0]) print('Corrupted file') return tokens def open_qasm_circuit(self): files_filter = 'QASM files (*.qasm);;All files (*.*)' name = QtWidgets.QFileDialog.getOpenFileName(self.window, 'Open File', filter=files_filter) extension = os.path.splitext(name[0])[1] if extension == '.qasm': try: new_circuit = q.QuantumCircuit().from_qasm_file(name[0]) new_test = QuantumTest( os.path.basename(os.path.splitext(name[0])[0]), new_circuit, 1024) self.default_tests.append(new_test) self.test_info_tab.add_new_test(new_test) self.dialog.add_new_test(new_test) except QasmError: msg = QtWidgets.QMessageBox() msg.setIcon(QtWidgets.QMessageBox.Critical) msg.setText('File %s is corrupted!' % os.path.splitext(name[0])[0]) msg.setWindowTitle('Error!') msg.exec_() def delete_results(self): indexes = self.results_info_tab.table_widget.selectionModel( ).selectedRows() for i in range(0, len(indexes)): self.results_info_tab.table_widget.removeRow(indexes[i].row()) self.results_info_tab.table_widget.resizeColumnsToContents() def open_results(self): # TODO files_filter = 'CSV files (*.csv);;All files (*.*)' name = QtWidgets.QFileDialog.getOpenFileName(self.window, 'Open File', filter=files_filter) extension = os.path.splitext(name[0])[1] if extension == '.csv': try: with open(name[0], newline='') as csvfile: csv_reader = csv.reader(csvfile, delimiter=';') headers = next(csv_reader, None) if headers != [ 'Test_name', 'Result', 'Backend_name', 'Job_status', 'Date', 'Shots_taken', 'Time_taken', 'Accuracy', 'Counts' ]: raise RuntimeError('Incorrect file format!') for row in csv_reader: if len(row) == 0: continue self.results_info_tab.table_widget.insertRow( self.results_info_tab.table_widget.rowCount()) dict_data = dict.fromkeys(headers) test = next( (x for x in self.default_tests if x.name == row[0]), QuantumTest(row[0], None, row[5], row[1])) if test not in self.default_tests: self.default_tests.append(test) dict_data[headers[0]] = row[0] self.results_info_tab.table_widget.setItem( self.results_info_tab.table_widget.rowCount() - 1, 0, MyTableWidgetItem(str(row[0]))) for j in range(2, 8): dict_data[headers[j]] = row[j] self.results_info_tab.table_widget.setItem( self.results_info_tab.table_widget.rowCount() - 1, j - 1, MyTableWidgetItem(str(row[j]))) dict_data[headers[8]] = row[8] test.results.append(dict_data) self.results_info_tab.table_widget.resizeColumnsToContents( ) except: msg = QtWidgets.QMessageBox() msg.setIcon(QtWidgets.QMessageBox.Critical) msg.setText("Oops! %s occurred." % sys.exc_info()[0]) msg.setWindowTitle('Error!') msg.exec_() def save_results(self): files_filter = 'CSV files (*.csv);;All files (*.*)' name = QtWidgets.QFileDialog.getSaveFileName(self.window, 'Save File', filter=files_filter) if all(name): func = self.writer.write_result( os.path.basename(os.path.splitext(name[0])[0]), self.default_tests) func() def save_qasm_circuit(self): files_filter = 'QASM files (*.qasm);;All files (*.*)' name = QtWidgets.QFileDialog.getSaveFileName(self.window, 'Save File', filter=files_filter) if all(name): file = open(name[0], 'w') text = self.test_info_tab.get_selected_test().circuit.qasm() file.write(text) file.close() def background_calc(self, cur_circuit, cur_computer): job = q.execute(cur_circuit, backend=cur_computer) job_monitor(job) self.__result = job.result() return job.result() def test_and_print(self, cur_test, computers): print('Starting test and print') worker = Worker(self.test_selected_computers, cur_test, computers) print('Pool start') self.thread_pool.start(worker) def print_s(self): print('s') def add_result_from_db(self, result: Result): self.results_info_tab.table_widget.insertRow( self.results_info_tab.table_widget.rowCount()) res_list = list() res_list.append(result.test_name) res_list.append(result.backend_name) res_list.append(result.job_status) res_list.append(result.date) res_list.append(result.shots) res_list.append(result.time) res_list.append(result.accuracy) for j in range(0, 7): self.results_info_tab.table_widget.setItem( self.results_info_tab.table_widget.rowCount() - 1, j, MyTableWidgetItem(str(res_list[j]))) self.results_info_tab.table_widget.resizeColumnsToContents() def add_new_result(self, result): self.results_info_tab.table_widget.insertRow( self.results_info_tab.table_widget.rowCount()) res_list = list(result.values()) result_value = result['Result'] res_list.remove(result_value) for j in range(0, 7): self.results_info_tab.table_widget.setItem( self.results_info_tab.table_widget.rowCount() - 1, j, MyTableWidgetItem(str(res_list[j]))) self.results_info_tab.table_widget.resizeColumnsToContents() def test_selected_computers(self, cur_test, computers): fields = [ 'Test_name', 'Backend_name', 'Job_status', 'Date', 'Shots_taken', 'Time_taken', 'Counts' ] print('start test_selected') print(str(self)) print(str(cur_test)) print(str(computers)) tabs = [] test = next(x for x in self.default_tests if x.name == cur_test) backend = None for computer in computers: try: backend = next(x for x in self.ibm_backends if str(x) == computer) except StopIteration: for back in self.inspire_backends: if computer == back['name']: backend = back if backend is None: raise RuntimeError('Unknown backend') tab = next(x for x in self.tab_infos if x.name == computer) tabs.append(tab) if computer in [ 'QX single-node simulator', 'QX single-node simulator SurfSara', 'Spin-2', 'Starmon-5' ]: worker = Worker2(test.run_inspire, backend, self.qi) print('Start inner pool') self.inner_thread_pool.start(worker) else: worker = Worker2(test.run_ibm, backend) print('Start inner pool') self.inner_thread_pool.start(worker) self.inner_thread_pool.waitForDone() for i in range(0, len(tabs)): self.drawer.plot_results2(tabs[i], test.not_drawn_res[i]['Counts']) print('Finished after testing work') for result in test.not_drawn_res: self.add_new_result(result) self.repo.insert_result(Result.create_result_from_dict(result)) test.not_drawn_res.clear() def enter_keys(self): self.registration_dialog.show_dialog() if self.registration_dialog.result() == QtWidgets.QDialog.Accepted: qiskit_token, dwave_token, inspire_token = self.registration_dialog.provide_api_tokens( ) is_update_necessary = False if self.__qiskit != qiskit_token: self.__qiskit = qiskit_token is_update_necessary = True if self.__dwave != dwave_token: self.__dwave = dwave_token is_update_necessary = True if self.__inspire != inspire_token: self.__inspire = inspire_token is_update_necessary = True if is_update_necessary: self.setup_tabs() self.dialog = TestCreationDialogWindow(self.tab_infos, self.default_tests) def choose_test(self): self.dialog.show_dialog() if self.dialog.result() == QtWidgets.QDialog.Accepted: test = self.dialog.get_selected_test() computers = self.dialog.get_selected_computers() if computers: self.test_and_print(test, computers) elif self.dialog.result() == QtWidgets.QDialog.Rejected: self.status_label.setText('Rejected') def show_status(self, message): def show(): self.status_label.setText(message) return show def setup_ui(self, main_window_local): main_window_local.setObjectName("main_window") main_window_local.resize(1024, 768) self.gridLayout_2 = QtWidgets.QGridLayout(self.central_widget) self.gridLayout_2.setObjectName("gridLayout_2") main_window_local.setCentralWidget(self.central_widget) self.menubar = QtWidgets.QMenuBar(main_window_local) self.menubar.setGeometry(QtCore.QRect(0, 0, 766, 21)) self.menubar.setObjectName("menubar") self.statusbar = QtWidgets.QStatusBar(main_window_local) self.statusbar.setObjectName("statusbar") main_window_local.setStatusBar(self.statusbar) self.menu_file = QtWidgets.QMenu(self.menubar) self.menu_file.setObjectName("menu_file") self.menu_service = QtWidgets.QMenu(self.menubar) self.menu_service.setObjectName("menu_service") self.menu_help = QtWidgets.QMenu(self.menubar) self.menu_help.setObjectName("menu_help") self.menu_edit = QtWidgets.QMenu(self.menubar) self.menu_edit.setObjectName("menu_edit") self.menu_edit.setStatusTip('Editing') main_window_local.setMenuBar(self.menubar) self.status_label = QtWidgets.QLabel(self.statusbar) self.status_label.setGeometry(5, -5, 500, 20) self.status_label.setObjectName('status_label') self.status_label.setText('') self.action_about = QtWidgets.QAction(main_window_local) self.action_about.setObjectName("action_about") self.action_about.setStatusTip('Подробнее о программе') self.action_registration = QtWidgets.QAction(main_window_local) self.action_registration.setObjectName('action_registration') self.action_registration.setStatusTip('Ввести ключи регистрации') self.action_registration.triggered.connect(self.enter_keys) self.action_new = QtWidgets.QAction(main_window_local) self.action_new.setObjectName("action_new") self.action_new.triggered.connect(self.choose_test) self.action_new.setStatusTip('Создать новый файл') self.test_info_tab.button_import.clicked.connect( self.open_qasm_circuit) self.test_info_tab.button_export.clicked.connect( self.save_qasm_circuit) self.results_info_tab.button_load.clicked.connect(self.open_results) self.results_info_tab.button_delete.clicked.connect( self.delete_results) self.action_open = QtWidgets.QAction(main_window_local) self.action_open.setObjectName("action_open") self.action_open.setStatusTip('Открыть файл результатов') self.action_save = QtWidgets.QAction(main_window_local) self.action_save.setObjectName("action_save") self.action_save.setStatusTip('Сохранить результаты') self.action_save_as = QtWidgets.QAction(main_window_local) self.action_save_as.setObjectName("action_save_as") self.action_save_as.setStatusTip('Сохранить результаты в новый файл') self.action_save_as.triggered.connect(self.save_results) self.action_close = QtWidgets.QAction(main_window_local) self.action_close.setObjectName("action_close") self.action_close.setStatusTip('Выйти из программы') self.action_update = QtWidgets.QAction(main_window_local) self.action_update.setObjectName("action_update") self.action_update.triggered.connect(self.clear_plots) self.action_update.setStatusTip('Очистить графики') self.action_test = QtWidgets.QAction(main_window_local) self.action_test.setObjectName("action_test") self.action_test.setStatusTip('Протестировать компьютеры') self.menu_file.addAction(self.action_new) self.menu_file.addAction(self.action_open) self.menu_file.addSeparator() self.menu_file.addAction(self.action_save) self.menu_file.addAction(self.action_save_as) self.menu_file.addSeparator() self.menu_file.addAction(self.action_close) self.menu_service.addAction(self.action_update) self.menu_service.addAction(self.action_test) self.menu_help.addAction(self.action_about) self.menu_help.addSeparator() self.menu_help.addAction(self.action_registration) self.menubar.addAction(self.menu_file.menuAction()) self.menubar.addAction(self.menu_edit.menuAction()) self.menubar.addAction(self.menu_service.menuAction()) self.menubar.addAction(self.menu_help.menuAction()) self.retranslate_ui(main_window_local) QtCore.QMetaObject.connectSlotsByName(main_window_local) def plot_result(self, cur_circuit, cur_result): def plot(): for tab_info in self.tab_infos: axes = tab_info.figure.add_subplot(111) axes.clear() plot_histogram(self.__result.get_counts(cur_circuit), ax=axes) tab_info.canvas.draw() return plot def clear_plots(self): for tab_info in self.tab_infos: axes = tab_info.figure.add_subplot(111) axes.clear() tab_info.canvas.draw() def plot_circuit(self, cur_circuit): for tab_info in self.tab_infos: axes = tab_info.figure.add_subplot(111) axes.clear() cur_circuit.draw(output='mpl', ax=axes) tab_info.canvas.draw() def retranslate_ui(self, main_window_local): _translate = QtCore.QCoreApplication.translate main_window_local.setWindowTitle( _translate("main_window", "QuantumTester 0.0.1 x64")) self.menu_file.setTitle(_translate("main_window", "Файл")) self.menu_service.setTitle(_translate("main_window", "Сервис")) self.menu_help.setTitle(_translate("main_window", "Помощь")) self.menu_edit.setTitle(_translate("main_window", "Правка")) self.action_about.setText(_translate("main_window", "О программе...")) self.action_registration.setText( _translate("main_window", "Регистрация")) self.action_new.setText(_translate("main_window", "Новый")) self.action_new.setShortcut(_translate("main_window", "Ctrl+N")) self.action_open.setText(_translate("main_window", "Открыть")) self.action_open.setShortcut(_translate("main_window", "Ctrl+O")) self.action_save.setText(_translate("main_window", "Сохранить")) self.action_save.setShortcut(_translate("main_window", "Ctrl+S")) self.action_save_as.setText( _translate("main_window", "Сохранить как...")) self.action_close.setText(_translate("main_window", "Закрыть")) self.action_update.setText(_translate("main_window", "Обновить")) self.action_test.setText(_translate("main_window", "Протестировать")) def setup_tabs(self): _translate = QtCore.QCoreApplication.translate self.ibm_backends = None self.dwave_backends = None self.inspire_backends = None self.rigetti_backends = None self.tab_infos = [] # backend1 = {'name': '9q-square-noisy-qvm', 'number_of_qubits': 9, # 'max_number_of_shots': 65536, 'max_experiments': 'unlimited', # 'description': 'v. 1.17', 'accuracy': 'not accurate', # 'remaining_jobs': 'unlimited'} # backend2 = {'name': '26q-qvm', 'number_of_qubits': 26, # 'max_number_of_shots': 65536, 'max_experiments': 'unlimited', # 'description': 'v. 1.17', 'accuracy': '0', # 'remaining_jobs': 'unlimited'} # self.rigetti_backends = [backend1, backend2] if self.__qiskit is not None: IBMQ.enable_account(self.__qiskit) ibm_provider = IBMQ.get_provider('ibm-q') self.ibm_backends = ibm_provider.backends() if self.__inspire is not None: enable_account(self.__inspire) QI.set_authentication() server_url = r'https://api.quantum-inspire.com' auth = get_token_authentication() self.qi = QuantumInspireAPI(server_url, auth) # backends = [] # for back in self.qi.get_backend_types(): # current_backend = {'name': back.get('name'), 'number_of_qubits': back.get('number_of_qubits'), # 'max_number_of_shots': back.get('max_number_of_shots'), # 'max_experiments': back.get('max_number_of_simultaneous_jobs'), # 'description': back.get('description'), 'accuracy': 'not measured', # 'remaining_jobs': back.get('max_number_of_simultaneous_jobs')} # backends.append(current_backend) self.inspire_backends = self.qi.get_backend_types() if self.ibm_backends is not None: for backend in self.ibm_backends: self.tab_infos.append(ComputerInfoTab(backend)) # if self.inspire_backends is not None: # for backend in self.inspire_backends: # # server = r'https://api.quantum-inspire.com' # # email = '*****@*****.**' # # password = '******' # # auth = HTTPBasicAuth(email, password) # # # # result = requests.get(f'{server}/projects', auth=auth) # # # # print(f'result status: {result.status_code}') # # print(result.json()) # # server = r'https://api.quantum-inspire.com' # # auth = coreapi.auth.TokenAuthentication(self.__inspire) # # client = coreapi.Client(auth=auth) # # content = client.get(f'{server}/backendtypes/1/calibration') # # print(content) # # action = ['projects', 'list'] # # result = client.action(schema, action) # # print(result) # # server = r'https://api.quantum-inspire.com' # # email = '*****@*****.**' # # password = '******' # # auth = HTTPBasicAuth(email, password) # # contents = urllib.request.urlopen(r'https://api.quantum-inspire.com/backendtypes/1/calibration/',).read() # self.tab_infos.append(ComputerInfoTab(backend._QuantumInspireBackend__backend)) if self.inspire_backends is not None: for backend in self.inspire_backends: self.tab_infos.append(ComputerInfoTab(backend)) if self.rigetti_backends is not None: for backend in self.rigetti_backends: self.tab_infos.append(ComputerInfoTab(backend)) self.tab_widget = QtWidgets.QTabWidget(self.central_widget) self.tab_widget.setObjectName("tabWidget") self.tab_widget.addTab(self.test_info_tab.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(self.test_info_tab.tab), _translate('main_window', self.test_info_tab.name)) self.tab_widget.addTab(self.results_info_tab.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(self.results_info_tab.tab), _translate('main_window', self.results_info_tab.name)) for tab_info in self.tab_infos: self.tab_widget.addTab(tab_info.tab, "") self.tab_widget.setTabText( self.tab_widget.indexOf(tab_info.tab), _translate("main_window", tab_info.tab.objectName())) self.gridLayout_2.addWidget(self.tab_widget, 0, 0, 1, 1) self.tab_widget.setCurrentIndex(0)
Args: eng (MainEngine): Main compiler engine the algorithm is being run on. qubits (Qureg): n-qubit quantum register Grover search is run on. output (Qubit): Output qubit to flip in order to mark the solution. """ with Compute(eng): All(X) | qubits[1::2] with Control(eng, qubits): X | output Uncompute(eng) # Remote Quantum-Inspire backend authentication = get_authentication() qi = QuantumInspireAPI(QI_URL, authentication) qi_backend = QIBackend(quantum_inspire_api=qi) compiler_engines = restrictedgateset.get_engine_list( one_qubit_gates=qi_backend.one_qubit_gates, two_qubit_gates=qi_backend.two_qubit_gates, other_gates=qi_backend.three_qubit_gates) compiler_engines.extend([ResourceCounter()]) qi_engine = MainEngine(backend=qi_backend, engine_list=compiler_engines) # Run remote Grover search to find a n-bit solution result_qi = run_grover(qi_engine, 3, alternating_bits_oracle) print("\nResult from the remote Quantum-Inspire backend: {}".format(result_qi)) # Local ProjectQ simulator backend compiler_engines = restrictedgateset.get_engine_list(one_qubit_gates="any",
from src.grover.run import * from quantuminspire.credentials import enable_account from quantuminspire.api import QuantumInspireAPI import time start_login = time.time() enable_account("58957ea5a48a801eb5af6adcae7776126c122c9d") qi = QuantumInspireAPI() print("Logged in to QI account ({} seconds)".format(str(time.time() - start_login)[:5]))\ backend = qi.get_backend_type_by_name('QX single-node simulator') shot_count = 500 # whether to apply optimization to our generated QASM # performance improvement of ~20-50% apply_optimization_to_qasm = True # MODES: # - normal: use toffoli gates and ancillary qubits for max speed # - no toffoli: same as normal, but replace toffoli gates for 2-gate equivalent circuits. uses ancillary qubits. # - crot: no ancillary qubits or toffoli gates, but scales with 3^n gates for n bits # - fancy cnot: no ancillary qubits or toffoli gates, scales 2^n mode = "normal" # Search example search_targets = [ "0110"[::-1], "1010"[::-1], ]
else: if QI_EMAIL is None or QI_PASSWORD is None: print('Enter email:') email = input() print('Enter password') password = getpass() else: email, password = QI_EMAIL, QI_PASSWORD return get_basic_authentication(email, password) if __name__ == '__main__': name = 'TestProjectQ' authentication = get_authentication() qi_api = QuantumInspireAPI(QI_URL, authentication, project_name=name) compiler_engines = restrictedgateset.get_engine_list(one_qubit_gates="any", two_qubit_gates=(CNOT,)) compiler_engines.extend([ResourceCounter()]) qi_backend = QIBackend(quantum_inspire_api=qi_api) engine = MainEngine(backend=qi_backend, engine_list=compiler_engines) qubits = engine.allocate_qureg(2) q1 = qubits[0] q2 = qubits[1] H | q1 CNOT | (q1, q2) All(Measure) | qubits
def testErrorCorrection(): server_url = r'https://api.quantum-inspire.com' print('Enter mail address') email = input() print('Enter password') password = getpass() auth = (email, password) qi = QuantumInspireAPI(server_url, auth) backend = qi.get_backend_type_by_name('QX single-node simulator') inputValues = [ { 'theta': 0, 'phi': 0 }, #|0> { 'theta': np.pi, 'phi': np.pi }, #|1> { 'theta': np.pi / 2, 'phi': np.pi / 2 } #|+> ] for inputValue in inputValues: print("Using input value " + str(inputValue)) allErrorIdxs = [] for nrOfErrors in range(2): allErrorIdxs += itertools.combinations(range(nbqubits), nrOfErrors) # iterate over all possible combinations of errors for errorIdxs in allErrorIdxs: inputStateComplex = _stateForInput(inputValue['theta'], inputValue['phi']) print("Introducing errors, indices " + str(errorIdxs)) QASM = createProgram(inputValue, errorIdxs) prob_0 = 0 prob_1 = 0 if 1: # Wavefunction result = qi.execute_qasm(QASM, backend_type=backend, number_of_shots=1) else: # Do measurements result = qi.execute_qasm(QASM, backend_type=backend, number_of_shots=10) result = result['histogram'] for key, value in zip(result.keys(), result.values()): if (int(key) % 2) == 0: #Number is odd prob_0 += value else: prob_1 += value if abs(prob_0 - abs(inputStateComplex[0])**2) < 0.0001 and abs( prob_1 - abs(inputStateComplex[1])**2) < 0.0001: print("Error correction works") else: print("Error correction fails")
from src.quantum_phase_estimation.util_functions import error_estimate from src.quantum_phase_estimation.util_functions import decimal_to_binary_fracion, find_max_value_keys, to_array from src.quantum_phase_estimation.processing.plotting import heatmap, graph from quantuminspire.credentials import load_account if __name__ == "__main__": QI_EMAIL = os.getenv('QI_EMAIL') QI_PASSWORD = os.getenv('QI_PASSWORD') QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/') tokens = [load_account()] qis = list( map( lambda x: QuantumInspireAPI( QI_URL, get_authentication( qi_email=QI_EMAIL, qi_password=QI_PASSWORD, token=x), 'Quantum Phase Estimation matrix'), tokens)) # variables desired_bit_accuracy = 6 minimum_chance_of_success = 0.5 mu = 0 sigma = 0.05 use_error_model = False use_multiple = True if False: topology = [['0', '1'], ['0', '3'], ['1', '2'], ['1', '4'], ['2', '5'], ['3', '4'], ['3', '6'], ['4', '5'], ['4', '7'], ['5', '8'], ['6', '7'], ['7', '8'], ['8', '9'], ['9', '10'], ['10', '11'], ['11', '12'], ['12', '13'], ['13', '14']]
def get_api_session(): return QuantumInspireAPI(QI_URL, get_authentication())