def ask_for_device (): d = input("Do you want to play on the real device? (y/n)\n").upper() if (d=="Y"): device = IBMQ.get_backend('ibmq_5_tenerife') # if real, we use ibmqx4 else: device = Aer.get_backend('qasm_simulator') # otherwise, we use a simulator return device
# Initial dataset real_data = take_from_dist_1(N) print('Data bounds:', bounds) print('Batch size:', batch_size) print('Number of qubits:', num_qubits) print('Target relative entropy:', target_rel_ent) print('Initial data length:', N) print('Initial data:', real_data) print('Unknown target probabilities:', unknown_target_data_prob) print('') # Set quantum instance to run the quantum generator if real_backend: print('Real backend loading...') IBMQ.load_account() # Load account from disk IBMQ.providers() # List all available providers provider = IBMQ.get_provider(hub='ibm-q') backend = provider.get_backend('ibmq_santiago') quantum_instance = QuantumInstance(backend=backend) print('Backend:', backend) print('') else: quantum_instance = QuantumInstance(backend=BasicAer.get_backend('statevector_simulator')) # Initialize qGAN iqgan = IQGAN( real_data, target_rel_ent, num_qubits, bounds,
from qiskit.aqua.components.oracles import TruthTableOracle from qiskit.aqua.circuits.gates import mcmt, mct from math import * import qconfig #n = int(sys.argv[1]) threshold = float(sys.argv[1]) delta = float(sys.argv[2]) vflag = int(sys.argv[3]) #print('delta : ', delta); #print('thresh : ', threshold); vprint = print if vflag else lambda *a, **k: None IBMQ.save_account(qconfig.APItoken, overwrite=True) IBMQ.load_accounts() backend = IBMQ.get_backend('ibmq_qasm_simulator') def swap(qc, q1, q2, anc): ln = range(len(q1)) for i in ln: qc.cx(q1[i], q2[i]) qc.cx(q2[i], q1[i]) qc.cx(q1[i], q2[i]) s = '' dat_file = open('data.txt', 'r')
import qiskit as q from qiskit import Aer, execute from qiskit import IBMQ from qiskit.tools.visualization import plot_histogram from qiskit.tools.monitor import job_monitor import matplotlib f = open('ibmtoken.txt') token = f.read() IBMQ.load_account() qr = q.QuantumRegister(2) cr = q.ClassicalRegister(2) circuit = q.QuantumCircuit(qr, cr) circuit.x(qr[0]) circuit.cx(qr[0], qr[1]) ##circuit.measure([qr[0],qr[1]],[cr[0],cr[1]])#measureing and storing result in classical bits ##simulator=Aer.get_backend('qasm_simulator')#using the qasm simulator ##Result=execute(circuit,backend=simulator).result() ##plot_histogram(Result.get_counts(circuit)).show() ##print(circuit) ##circuit.draw(output = 'mpl',filename='ckt.png') provider = IBMQ.get_provider('ibm-q') #using actual quantum computer qcomp = provider.get_backend('ibmq_16_melbourne') #using the ibmq_16_melbourne job = execute(circuit, backend=qcomp) job_monitor(job) #monitoring for the completion of our job result = job.result() plot_histogram(result.get_counts(circuit)).show() #plotting the results
import qiskit from qiskit import IBMQ, ClassicalRegister, QuantumRegister, QuantumCircuit, execute, Aer from qiskit.providers.ibmq import least_busy from configparser import RawConfigParser # Setup the API key for the real quantum computer. parser = RawConfigParser() parser.read('config.ini') IBMQ.enable_account(parser.get('IBM', 'key')) # Setup 3 qubits. q = QuantumRegister(3) c = ClassicalRegister(3) qc = QuantumCircuit(q, c) # Place the qubits into superposition so the qubits no longer hold a distinct value, but instead are both 0 and 1 at the same time (50% 0, 50% 1). qc.h(q) qc.measure(q, c) # Using the qubits and their random value, form a response. def answer(result): for key in result.keys(): state = key print("The Quantum 8-ball says:") if state == '000': print('It is certain.') elif state == '001': print('Without a doubt.') elif state == '010': print('Yes - deinitely.')
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, Aer from qiskit.tools.visualization import circuit_drawer import math as m from qiskit import IBMQ IBMQ.load_account() S_simulator = Aer.backends(name='statevector_simulator')[0] M_simulator = Aer.backends(name='qasm_simulator')[0] q = QuantumRegister(1, name='q') c = ClassicalRegister(1, name='c') qc = QuantumCircuit(q, c, name='qc') qc.rx(m.pi / 4, q[0]) print(circuit_drawer(qc)) qc.ry(m.pi / 4, q[0]) print(circuit_drawer(qc)) qc.rz(m.pi / 4, q[0]) print(circuit_drawer(qc))
# In[1]: import qiskit # In[2]: from qiskit import IBMQ # In[3]: IBMQ.save_account('e09fd3916c85a0a4c4eb21ffec6ee48758d13a8e3b76c50e6301b7f3e28656d157dd4f406530ae18ccbee21bc6f4685b6271433292b424a81eeb3cebcb04d85b') # In[4]: IBMQ.load_account() # In[5]: from qiskit import * # In[6]:
import tensorflow as tf import os import qiskit from qiskit import IBMQ from qiskit.providers.aer.noise import NoiseModel ################################################################################################## # Use default.qubit for default pennylane simulation # use tf.interface for TF integration USE_GPU = (os.environ["CUDA_VISIBLE_DEVICES"] != '-1') # Read token from file f = open("qnetworks/.ibmq_token", "r") token = f.readline() f.close() # connect IBM and get device noise information IBMQ.save_account(token) provider = IBMQ.load_account() backend = provider.get_backend('ibmq_16_melbourne') noise_model = NoiseModel.from_backend(backend) dev1 = qml.device('qiskit.aer', wires=8, noise_model=noise_model) @qml.qnode(dev1, interface='tf') def TTN_edge_forward(edge_array, theta_learn): # Takes the input and learning variables and applies the # network to obtain the output # STATE PREPARATION for i in range(8): qml.RY(edge_array[i], wires=i) # First Layer
# Needed for functions import numpy as np import time # Import Qiskit classes import qiskit from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, Aer from qiskit.quantum_info import state_fidelity from qiskit import Aer, IBMQ, execute from qiskit.providers.aer import noise IBMQ.load_accounts() IBMQ.backends() device = IBMQ.get_backend('ibmq_16_melbourne') properties = device.properties() coupling_map = device.configuration().coupling_map gate_times = [('u1', None, 0), ('u2', None, 100), ('u3', None, 200), ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721), ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800), ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895), ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800), ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773), ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)] noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times) import sys, os #sys.path.append('/Users/atanteck/Desktop/project/qiskit-ignis/qiskit/ignis') from verification import tomography as tomo from mitigation import measurement as mc
# uncompute for i in range(self.n - 1, 1, -1): self.circ.ccx(self.ctrl[i], self.anc[i - 2], self.anc[i - 1]) self.circ.ccx(self.ctrl[0], self.ctrl[1], self.anc[0]) def calc_theta(self, p1, p0): return 2 * np.arctan(np.sqrt((p1) / (p0))) #if __name__=='__main__': from jupyterthemes import jtplot jtplot.style(theme='monokai', context='notebook', ticks=True, grid=False) from qiskit.tools.jupyter import * from qiskit import IBMQ IBMQ.load_account() # provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') provider = IBMQ.get_provider(hub='ibm-q-oxford', group='on-boarding', project='on-boarding-proj') from qiskit import BasicAer backend = BasicAer.get_backend('unitary_simulator') n = 3 parents = np.random.rand(n * 2) child = np.random.rand(2**(n + 1)) b = byskit(provider, backend, n, parents, child)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created Nov 2020 @author: hassi """ from qiskit import QuantumCircuit, execute from qiskit import IBMQ from qiskit.tools.monitor import job_monitor from IPython.core.display import display print("Getting provider...") if not IBMQ.active_account(): IBMQ.load_account() provider = IBMQ.get_provider() print("Ch 4: Quantum coin toss on IBM Q backend") print("----------------------------------------") qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) display(qc.draw('mpl')) from qiskit.providers.ibmq import least_busy backend = least_busy(
from __future__ import print_function import tbvaccine as tb tb.add_hook(isolate=False, show_vars=False) import numpy as np from qiskit.quantum_info.operators import Operator from qiskit import (IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute, transpile) ################################################################################ ################################################## ################### Token auth ################### ################################################## token_path = "../IBMQ_token" with open(token_path, "r") as file: token = file.read() IBMQ.save_account(token, overwrite=True) ################################################################################ ##################################### Main ##################################### ################################################################################ def main(): ################################################## ################## Make circuit ################## ################################################## q = QuantumRegister(3) c = ClassicalRegister(3) circ = QuantumCircuit(q, c) circ.x(q[0]) # |psi> = |1> ########## Encoding ########## circ.barrier()
# <IBMQBackend('ibmq_16_melbourne') from IBMQ()>, # <IBMQBackend('ibmq_qasm_simulator') from IBMQ()> # ] # IBMQ device information: # https://www.research.ibm.com/ibm-q/technology/devices/#ibmqx4 backend = qiskit.Aer.get_backend('qasm_simulator') shots = 1024 backend_result = qiskit.execute(circs, backend, shots=shots).result() for i in range(len(circs)): print(backend_result.get_counts(circs[i])) # print(backend_result.get_counts(circs[0])) print(xdata) # gate_time * num_of_gates # Run on an IBMQ device # Ref: # https://qiskit.org/documentation/advanced_use_of_ibm_q_devices.html IBMQ.load_accounts() backend = IBMQ.get_backend('ibmqx2') for i in range(len(circs)): qobj = compile(circs[i], backend=backend, shots=1024) job = backend.run(qobj) result = job.result() counts = result.get_counts() print(counts) # Measure the value of T*2 (decoherence) time # https://github.com/Qiskit/qiskit-tutorials/blob/master/community/ignis/coherence-overview.ipynb
import matplotlib.pyplot as plt from qiskit import BasicAer, Aer, QuantumCircuit, QuantumRegister, ClassicalRegister, execute, IBMQ from qiskit.visualization import * from qiskit.tools.monitor import job_monitor import math ######################################################### ######################################################### # #INIT qasm = Aer.get_backend('qasm_simulator') IBMQ.load_account() # Init Real Quantum computeur provider = IBMQ.get_provider('ibm-q') quantum_computer = provider.get_backend('ibmq_burlington') backend_sim = qasm # Choose your backend : <quantom_computer> or <qasm> statevector_sim = Aer.get_backend("statevector_simulator") ship = ["petit", "moyen", "grand"] nb_qubits = len(ship) qubits = [1, 2, 3, 4, 5] fake_qubit = 5 - nb_qubits play = True ######################################################### ######################################################### # #Circuit # Quantum Circuit
from qiskit import IBMQ IBMQ.save_account('API_KEY') from qiskit import (QuantumCircuit, execute, Aer) from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter) import math import random # To run as a simulation, replace all 'backend' with 'simulator', and uncomment: # simulator = Aer.get_backend('qasm_simulator') qc = QuantumCircuit(5, 5) qc.h(0) qc.h(1) qc.h(2) qc.h(3) qc.h(4) qc.measure([0, 1, 2, 3, 4], [0, 1, 2, 3, 4]) IBMQ.load_account() provider = IBMQ.get_provider('ibm-q') backend = provider.get_backend('ibmq_ourense') # If no mitigation is applied, add ', memory=True', and .get_memory() to job.result() job = execute(qc, backend, shots=4096, optimization_level=0) results = job.result() # Mitigation Measurement, will run twice
#!/usr/bin/env python # coding: utf-8 # In[1]: import qiskit # In[2]: qiskit.__qiskit_version__ # In[3]: from qiskit import IBMQ # In[4]: IBMQ.save_account( '3911c2d0a5d9bf2e5e04c515e91669718a1aceb5465035e11e71d8ad57b65d99316ab8da9610dd12e72bf925bf347f080b6067ce942cd7fb6b828e15784b09c3' ) # In[5]: IBMQ.load_account() # In[ ]:
from qiskit import IBMQ, Aer from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister import matplotlib.pyplot as plt import os from rwutil import * OUTPUT = "output" IBMQ.load_account() Prov = IBMQ.get_provider(group='open') BACKENDS = { 'qasm_simulator': (Aer.get_backend('qasm_simulator'), True), 'ibmq_qasm_simulator': (Prov.get_backend('ibmq_qasm_simulator'), False), 'ibmq_london': (Prov.get_backend('ibmq_qasm_simulator'), False), 'ibmq_vigo': (Prov.get_backend('ibmq_qasm_simulator'), False) } SHOTS = 1000 T = [*range(0, 5)] N = [2, 3, 4, 5] def add_gate(): # 0 = cin, 1 = q, 2 = cout q = QuantumRegister(3) circuit = QuantumCircuit(q, name='add') circuit.ccx(0, 1, 2) circuit.cx(0, 1) return circuit.to_instruction()
def main(): st.header("Моделирование. Лабораторная работа №1") st.write("Исследование последовательности псевдослучайных чисел") random_type = st.radio( "Выберите метод получения чисел", ("Алгоритмическая генерация", "Пользовательский ввод", "Пуассон", "Квантовая генерация")) if random_type == "Алгоритмическая генерация": st.markdown("---") random_table = RAND_TABLE.replace(" ", "").replace("\n", "") table_cap_1 = random_table[:10] table_cap_2 = random_table[11:31] table_cap_3 = random_table[32:62] tbl_1 = np.array([int(s) for s in table_cap_1], dtype=np.int16) tbl_2 = np.array( [table_cap_2[i:i + 2] for i in range(0, len(table_cap_2), 2)], dtype=np.int16) tbl_3 = np.array( [table_cap_3[i:i + 3] for i in range(0, len(table_cap_3), 3)], dtype=np.int16) alg_1 = gen_rnd_smpl(0, 9) alg_2 = gen_rnd_smpl(10, 99) alg_3 = gen_rnd_smpl(100, 999) st.write( "Табличный и алгоритмический метод получения псевдослучайных чисел." ) generate_table(data=np.array([ tbl_1, tbl_2, tbl_3, alg_1, alg_2, alg_3, ]), columns=["Табл.", "Алг."]) st.button("Сгенерировать") if st.checkbox("Показать графики"): st.line_chart(tbl_1) st.line_chart(tbl_2) st.line_chart(tbl_3) st.line_chart(alg_1) st.line_chart(alg_2) st.line_chart(alg_3) elif random_type == "Пользовательский ввод": st.markdown("---") st.write("Пользовательский ввод случайных чисел.") user_nums_cap_1 = user_input_handler(digit_capacity=1, key=1) user_nums_cap_2 = user_input_handler(digit_capacity=2, key=2) user_nums_cap_3 = user_input_handler(digit_capacity=3, key=3) if user_nums_cap_1.shape[0] + user_nums_cap_2.shape[ 0] + user_nums_cap_3.shape[0] == 30: generate_table(data=np.array( [user_nums_cap_1, user_nums_cap_2, user_nums_cap_3]), columns=["Польз."]) if st.checkbox("Показать графики"): st.line_chart(user_nums_cap_1) st.line_chart(user_nums_cap_2) st.line_chart(user_nums_cap_3) elif random_type == "Пуассон": st.markdown("---") st.write( "Генерация случайных чисел с использованием распределения Пуассона" ) poisson_cap_1 = np.random.poisson(3, 10) poisson_cap_2 = np.random.poisson(33, 10) poisson_cap_3 = np.random.poisson(333, 10) generate_table(data=np.array( [poisson_cap_1, poisson_cap_2, poisson_cap_3]), columns=["Пуассон"]) st.button("Сгенерировать") elif random_type == "Квантовая генерация": st.markdown("---") st.write( "Генерация случайных чисел с использованием квантового компьютера IBM." ) api_key = None try: IBMQ.load_account() except Exception as e: api_key = st.text_input("Введите IBMQ API Key:") if not api_key: IBMQ.save_account(api_key, overwrite=True) IBMQ.load_account() rng_provider = IBMQ.get_provider(hub='ibm-q') device = st.selectbox("Select Quantum Device", [str(each) for each in rng_provider.backends()]) backend = rng_provider.get_backend(device) generator = Generator(backend=backend) if device == "ibmq_qasm_simulator": num_q = 32 else: num_q = 5 quantum_nums_cap_1 = [] quantum_nums_cap_2 = [] quantum_nums_cap_3 = [] for i in range(10): quantum_nums_cap_1.append(ibmq_qrng(num_q, 0, 9)) quantum_nums_cap_2.append(ibmq_qrng(num_q, 10, 99)) quantum_nums_cap_3.append(ibmq_qrng(num_q, 100, 999)) generate_table(data=np.array( [quantum_nums_cap_1, quantum_nums_cap_2, quantum_nums_cap_3]), columns=["Квант."]) st.button("Сгенерировать") if st.checkbox("Показать графики"): st.line_chart(quantum_nums_cap_1) st.line_chart(quantum_nums_cap_2) st.line_chart(quantum_nums_cap_3)
import numpy as np from qiskit import( QuantumCircuit, execute, Aer, IBMQ) from qiskit.visualization import plot_histogram from matplotlib import pyplot as plt #IBMQ.save_account('c650f2a6e47504e201bd6e1422e89efbb3b1ac24264be980a0555746424cd5d8469e1511b86a10f0f3fd1581245d864bcbe03b0802ce48dff35adc57a44da5f6') IBMQ.load_account() provider = IBMQ.get_provider(group='open', project='main') backend = provider.get_backend('ibmq_vigo') #backend = Aer.get_backend('qasm_simulator') circuit = QuantumCircuit(2, 2) circuit.h(0) circuit.cx(0,1) circuit.measure([0,1],[0,1]) job = execute(circuit,backend, shots=1000) result = job.result() counts = result.get_counts() print("\nTotal count for 00 and 11 are:",counts) print(circuit.draw(output="text",filename=None)) plot_histogram(counts) plt.show()
# Create a GHZ state qc.h(q[0]) for i in range(4): qc.cx(q[i], q[i + 1]) # Insert a barrier before measurement qc.barrier() # Measure all of the qubits in the standard basis for i in range(5): qc.measure(q[i], c[i]) ############################################################### # Set up the API and execute the program. ############################################################### try: IBMQ.load_accounts() except: print("""WARNING: There's no connection with the API for remote backends. Have you initialized a file with your personal token? For now, there's only access to local simulator backends...""") # First version: simulator sim_backend = Simulators.get_backend('qasm_simulator') job = execute(qc, sim_backend, shots=1024) result = job.result() print('Qasm simulator') print(result) print(result.get_counts(qc)) # Second version: real device least_busy_device = least_busy(
from qiskit import QuantumRegister, ClassicalRegister from qiskit import QuantumCircuit, execute,IBMQ from qiskit.tools.monitor import job_monitor from qiskit.circuit.library import QFT import numpy as np pi = np.pi IBMQ.enable_account(‘ENTER API KEY HERE’) provider = IBMQ.get_provider(hub='ibm-q') backend = provider.get_backend('ibmq_qasm_simulator') q = QuantumRegister(5,'q') c = ClassicalRegister(5,'c') circuit = QuantumCircuit(q,c) circuit.x(q[4]) circuit.x(q[2]) circuit.x(q[0]) circuit += QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=False, name='qft') circuit.measure(q,c) circuit.draw(output='mpl', filename='qft1.png') print(circuit) job = execute(circuit, backend, shots=1000) job_monitor(job) counts = job.result().get_counts()
from qiskit.circuit import QuantumCircuit,QuantumRegister,ClassicalRegister from qiskit import execute from qiskit import IBMQ from qiskit import BasicAer #IBMQ.save_account('83a95fc7efba05f250ed50ff6bdf1638541ebd4f9e46396f26c8dc12f15b2331ea24d9db4f59c30b6e397c2268e40ddc1dae4772091baa73d7e99c91e8d8c56b') provider = IBMQ.load_account() backend = provider.get_backend('ibmq_quito') qr = QuantumRegister(3) cr =ClassicalRegister(3) qc = QuantumCircuit(qr,cr) qc.h(0) qc.cx(0,1) qc.cx(0,2) qc.measure(qr[0:],cr[0:]) for _ in range(20): job = execute(qc,backend = backend,shots = 1024) counts = job.result().get_counts() print(counts)
#!/usr/bin/env python # coding: utf-8 # In[1]: from qiskit import QuantumRegister from qiskit import QuantumRegister, ClassicalRegister from qiskit import QuantumCircuit, execute, IBMQ from qiskit.tools.monitor import job_monitor print('\nSign Flip Code') print('----------------') IBMQ.enable_account( '7a14c59cb5d061ddf7b9287874a80aa122f1cae65910e33fa678220ec5d475a637b83a0e9f8f54a43e3a128d5e5154f084a924dbfdef0da5a3e777c940a15b55' ) provider = IBMQ.get_provider(hub='ibm-q') backend = provider.get_backend('ibmq_qasm_simulator') # Creating Qubits q = QuantumRegister(3) # Creating qubits circuit = QuantumCircuit(q) # Hadamard Gate on the first Qubit circuit.h(q[0]) # Pauli Z Gate on the the first qubit circuit.z(0) # Pauli Z Gate on the the second qubit circuit.z(1) # CNOT Gate on the first and second Qubits
# Create a GHZ state qc.h(q[0]) for i in range(num_qubits-1): qc.cx(q[i], q[i+1]) # Insert a barrier before measurement qc.barrier() # Measure all of the qubits in the standard basis for i in range(num_qubits): qc.measure(q[i], c[i]) ############################################################### # Set up the API and execute the program. ############################################################### try: IBMQ.load_accounts() except: print("""WARNING: There's no connection with the API for remote backends. Have you initialized a file with your personal token? For now, there's only access to local simulator backends...""") # First version: simulator sim_backend = BasicAer.get_backend('qasm_simulator') job = execute(qc, sim_backend, shots=1024) result = job.result() print('Qasm simulator : ') print(result.get_counts(qc)) # Second version: real device least_busy_device = least_busy(IBMQ.backends(simulator=False, filters=lambda x: x.configuration().n_qubits > 4))
#!/usr/bin/env python # coding: utf-8 print("Ch 8: Aer out of the box, a perfect quantum computer") print("----------------------------------------------------") # Import Qiskit from qiskit import QuantumCircuit from qiskit import Aer, IBMQ, execute # Import visualization tools from qiskit.tools.visualization import plot_histogram from qiskit.tools.monitor import job_monitor # Load account IBMQ.load_account() provider = IBMQ.get_provider() # Enter number of SWAP gates to include with your circuit with (default 20) user_input = input("Enter number of SWAP gates to use: ") try: n = int(user_input) except ValueError: n = 10 n_gates = n # Construct quantum circuit circ = QuantumCircuit(2, 2) circ.x(0) while n > 0: circ.swap(0, 1)
import csv import datetime import os from qiskit import IBMQ IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q-education', group='technion-Weinste') log_time = datetime.datetime.now() def write_log_to_file(csv_writer): for backend in provider.backends(): try: for qubit_idx, qubit_prop in enumerate( backend.properties().qubits): for prop in qubit_prop: csv_writer.writerow([ backend.name(), qubit_idx, prop.date.isoformat(), prop.name, prop.unit, prop.value, log_time.isoformat() ]) id_gate = [ i for i in backend.properties().gates if i.gate == 'id' and qubit_idx in i.qubits ][0] id_gate_length = [ p for p in id_gate.parameters if p.name == 'gate_length' ][0] csv_writer.writerow([
def run_algorithm(params, algo_input=None, json_output=False, backend=None): """ Run algorithm as named in params, using params and algo_input as input data and returning a result dictionary Args: params (dict): Dictionary of params for algo and dependent objects algo_input (AlgorithmInput): Main input data for algorithm. Optional, an algo may run entirely from params json_output (bool): False for regular python dictionary return, True for json conversion backend (BaseBackend): Backend object to be used in place of backend name Returns: Result dictionary containing result of algorithm computation """ _discover_on_demand() inputparser = InputParser(params) inputparser.parse() inputparser.validate_merge_defaults() logger.debug('Algorithm Input: {}'.format( json.dumps(inputparser.get_sections(), sort_keys=True, indent=4))) algo_name = inputparser.get_section_property(PluggableType.ALGORITHM.value, JSONSchema.NAME) if algo_name is None: raise AquaError('Missing algorithm name') if algo_name not in local_pluggables(PluggableType.ALGORITHM): raise AquaError( 'Algorithm "{0}" missing in local algorithms'.format(algo_name)) if algo_input is None: input_name = inputparser.get_section_property('input', JSONSchema.NAME) if input_name is not None: input_params = copy.deepcopy( inputparser.get_section_properties('input')) del input_params[JSONSchema.NAME] convert_json_to_dict(input_params) algo_input = get_pluggable_class( PluggableType.INPUT, input_name).from_params(input_params) algo_params = copy.deepcopy(inputparser.get_sections()) algorithm = get_pluggable_class(PluggableType.ALGORITHM, algo_name).init_params( algo_params, algo_input) random_seed = inputparser.get_section_property(JSONSchema.PROBLEM, 'random_seed') algorithm.random_seed = random_seed quantum_instance = None # setup backend backend_name = inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.NAME) if backend_name is not None: # quantum algorithm backend_cfg = { k: v for k, v in inputparser.get_section(JSONSchema.BACKEND).items() if k != 'name' } noise_params = backend_cfg.pop('noise_params', None) backend_cfg['config'] = {} backend_cfg['config']['noise_params'] = noise_params backend_cfg['seed'] = random_seed backend_cfg['seed_mapper'] = random_seed pass_manager = PassManager() if backend_cfg.pop( 'skip_transpiler', False) else None if pass_manager is not None: backend_cfg['pass_manager'] = pass_manager if backend is not None and isinstance(backend, BaseBackend): backend_cfg['backend'] = backend else: try: backend_from_name = get_aer_backend(backend_name) except: QuantumInstance.register_and_get_operational_backends() backend_from_name = IBMQ.get_backend(backend_name) backend_cfg['backend'] = backend_from_name quantum_instance = QuantumInstance(**backend_cfg) value = algorithm.run(quantum_instance) if isinstance(value, dict) and json_output: convert_dict_to_json(value) return value
elif quantumChoice == "10": print("The Quantum Computer chose: Scissors") else: print("The Quantum Computer chose: Quantum") #---------------------Program starts here--------------------- choice = userChoice() while choice == "default": print("Please try again: ") choice = userChoice() print("Loading quantum opponent...") # Load IBMQ account IBMQ.load_accounts() # Finds the least busy IBM quantum computer to use as the backend backend = BasicAer.get_backend('statevector_simulator') # Run a simulation #backend = least_busy(IBMQ.backends(simulator=False)) # Run it on IBM's computer print("The least busy device:", backend.name()) # Set up Quantum Register and Classical Register for 2 qubits q = QuantumRegister(2) c = ClassicalRegister(2) # Create a Quantum Circuit qc = QuantumCircuit(q, c) qc.h(q) # Hadamard gate that give the qubits an equal opportunity #qc.measure(q,c) #print(qc.draw()) # Display circuit
prog.x(input_qubit[0]) # number=19 prog.x(input_qubit[0]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog if __name__ == '__main__': a = "111" b = "0" f = lambda rep: bitwise_xor(bitwise_dot(a, rep), b) prog = make_circuit(4, f) IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q') provider.backends() backend = least_busy( provider.backends( filters=lambda x: x.configuration().n_qubits >= 2 and not x. configuration().simulator and x.status().operational == True)) sample_shot = 8000 info = execute(prog, backend=backend, shots=sample_shot).result().get_counts() backend = FakeVigo() circuit1 = transpile(prog, backend, optimization_level=2) writefile = open("../data/startQiskit_QC2594.csv", "w") print(info, file=writefile)
print('\nPhase Flip Code') print('----------------') from qiskit import QuantumRegister from qiskit import QuantumRegister, ClassicalRegister from qiskit import QuantumCircuit, execute, IBMQ from qiskit.tools.monitor import job_monitor IBMQ.enable_account('Enter API key here') provider = IBMQ.get_provider(hub='ibm-q') backend = provider.get_backend('ibmq_qasm_simulator') q = QuantumRegister(3, 'q') c = ClassicalRegister(1, 'c') circuit = QuantumCircuit(q, c) circuit.cx(q[0], q[1]) circuit.cx(q[0], q[2]) circuit.h(q[0]) circuit.h(q[1]) circuit.h(q[2]) circuit.z(q[0]) #Add this to simulate a phase flip error circuit.h(q[0]) circuit.h(q[1]) circuit.h(q[2]) circuit.cx(q[0], q[1]) circuit.cx(q[0], q[2]) circuit.ccx(q[2], q[1], q[0]) circuit.measure(q[0], c[0])
from qiskit import IBMQ from qiskit import BasicAer as Aer from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit from qiskit import execute import numpy as np import matplotlib.pyplot as plt from matplotlib.patches import Circle, Rectangle import copy from ipywidgets import widgets from IPython.display import display, clear_output try: IBMQ.load_accounts() except: pass class run_game(): # Implements a puzzle, which is defined by the given inputs. def __init__(self,initialize, success_condition, allowed_gates, vi, qubit_names, eps=0.1, backend=Aer.get_backend('qasm_simulator'), shots=1024,mode='circle',verbose=False): """ initialize List of gates applied to the initial 00 state to get the starting state of the puzzle. Supported single qubit gates (applied to qubit '0' or '1') are 'x', 'y', 'z', 'h', 'ry(pi/4)'. Supported two qubit gates are 'cz' and 'cx'. Specify only the target qubit. success_condition Values for pauli observables that must be obtained for the puzzle to declare success. allowed_gates For each qubit, specify which operations are allowed in this puzzle. 'both' should be used only for operations that don't need a qubit to be specified ('cz' and 'unbloch'). Gates are expressed as a dict with an int as value. If this is non-zero, it specifies the number of times the gate is must be used (no more or less) for the puzzle to be successfully solved. If the value is zero, the player can use the gate any number of times.
QX_TOKEN = APItoken """ Authenticate with the IBM Q API in order to use online devices. You need the API Token. The account information is need to be stored locally on disk only once. To store account information locally on disk, uncomment the next line. """ # print("Storing account information locally on disk ...") # IBMQ.save_account(QX_TOKEN) # The next line is mandatory to load the account infos stored print("\nLoading account ...") IBMQ.load_accounts() # print_dict(IBMQ.stored_accounts()[0]) """ ########### CREATING THE CIRCUIT ########## """ print("\nCreating the circuit ...") # Numbers of qubits that will be used in the circuit numbers_of_qubits = 4 # Create a Quantum Register with n qubits. q = QuantumRegister(numbers_of_qubits)