def __enter__(self): ''' Enter context, Attributes: eng (MainEngine): main engine. backend ('graphical' or 'simulate'): backend used. qureg (Qureg): quantum register. ''' if self.task == 'ibm': import projectq.setups.ibm else: import projectq.setups.default # create a main compiler engine with a specific backend: if self.task == 'draw': self.backend = CircuitDrawer() # locations = {0: 0, 1: 1, 2: 2, 3:3} # swap order of lines 0-1-2. # self.backend.set_qubit_locations(locations) elif self.task == 'simulate': print( 'ProjecQ simulation in training can be slow, since in scipy context, we cached a lot gates.' ) self.backend = Simulator(gate_fusion=True) elif self.task == 'ibm': # choose device device = self.ibm_config.get( 'device', 'ibmqx2' if self.num_bit <= 5 else 'ibmqx5') # check data if self.ibm_config is None: raise if device == 'ibmqx5': device_num_bit = 16 else: device_num_bit = 5 if device_num_bit < self.num_bit: raise AttributeError( 'device %s has not enough qubits for %d bit simulation!' % (device, self.num_bit)) self.backend = IBMBackend(use_hardware=True, num_runs=self.ibm_config['num_runs'], user=self.ibm_config['user'], password=self.ibm_config['password'], device=device, verbose=True) else: raise ValueError('engine %s not defined' % self.task) self.eng = MainEngine(self.backend) # initialize register self.qureg = self.eng.allocate_qureg(self.num_bit) return self
def is_available(self, cmd): """ Check if the IBM backend can perform the Command cmd and return True if so. Args: cmd (Command): The command to check """ return IBMBackend().is_available(cmd)
def initialize_quantum_engine(self): """ Quantum Engine Initializer (pass credentials namedtuple to use IBM's Quantum Computer with your username and password, otherwise will simulate locally) """ if self.credentials: quantum_engine = MainEngine( IBMBackend(user=self.credentials.username, password=self.credentials.password, use_hardware=self.remote_hardware), engine_list=projectq.setups.ibm.get_engine_list()) else: quantum_engine = MainEngine() return quantum_engine
# allocate the quantum register to entangle qureg = eng.allocate_qureg(num_qubits) # entangle the qureg Entangle | qureg # measure; should be all-0 or all-1 All(Measure) | qureg # run the circuit eng.flush() # access the probabilities via the back-end: results = eng.backend.get_probabilities(qureg) for state in results: print("Measured {} with p = {}.".format(state, results[state])) # return one (random) measurement outcome. return [int(q) for q in qureg] if __name__ == "__main__": # create main compiler engine for the IBM back-end eng = MainEngine(IBMBackend(use_hardware=False, num_runs=1024, verbose=False, device='ibmqx4'), engine_list=projectq.setups.ibm.get_engine_list()) # run the circuit and print the result print(run_entangle(eng))
import projectq.setups.ibm from projectq.ops import H, Measure from projectq import MainEngine from projectq.backends import IBMBackend # create a main compiler engine eng = MainEngine(IBMBackend(True)) # allocate one qubit q1 = eng.allocate_qubit() # put it in superposition H | q1 # measure Measure | q1 eng.flush() # print the result: print("Measured: {}".format(int(q1)))
# -*- coding: utf-8 -*- # pylint: skip-file """Example of a simple quantum random number generator using IBM's API.""" import projectq.setups.ibm from projectq import MainEngine from projectq.backends import IBMBackend from projectq.ops import H, Measure # create a main compiler engine eng = MainEngine(IBMBackend(), engine_list=projectq.setups.ibm.get_engine_list()) # allocate one qubit q1 = eng.allocate_qubit() # put it in superposition H | q1 # measure Measure | q1 eng.flush() # print the result: print("Measured: {}".format(int(q1)))
from projectq import MainEngine # import the main compiler engine from projectq.ops import H, Measure # import the operations we want to perform (Hadamard and measurement) from projectq.backends import IBMBackend import os # extract IBM Quantum Experience login details from environ ibmqe_user = os.environ.get('IBMQE_USER') ibmqe_password = os.environ.get('IBMQE_PASSWORD') # login to IBM and instantiate the quantumEngine object compiler_engines = ibm_setup.get_engine_list() eng = MainEngine(IBMBackend(use_hardware=True, num_runs=1024, verbose=False, user=ibmqe_user, password=ibmqe_password, device='ibmqx5', num_retries=3000, interval=1, retrieve_execution=None), engine_list=compiler_engines) # allocate a quantum register with 1 qubit qubit = eng.allocate_qubit() # apply a Hadamard gate to put in super position H | qubit # measure the qubit Measure | qubit
All(H) | [qureg[e[0]], qureg[e[1]]] CNOT | (qureg[e[0]], qureg[e[1]]) All(H) | [qureg[e[0]], qureg[e[1]]] else: CNOT | (qureg[e[0]], qureg[e[1]]) # measure; should be all-0 or all-1 Measure | qureg # run the circuit eng.flush() # access the probabilities via the back-end: results = eng.backend.get_probabilities(qureg) for state, probability in sorted(list(results.items())): print("Measured {} with p = {}.".format(state, probability)) # return one (random) measurement outcome. return [int(q) for q in qureg] if __name__ == "__main__": # create main compiler engine for the 16-qubit IBM back-end eng = MainEngine( IBMBackend(use_hardware=True, num_runs=1024, verbose=False, device='ibmqx5')) # run the circuit and print the result print(run_test(eng))
histogram(eng.backend, qureg) plt.show() # return one (random) measurement outcome. return [int(q) for q in qureg] if __name__ == "__main__": #devices commonly available : # ibmq_16_melbourne (15 qubit) # ibmq_essex (5 qubit) # ibmq_qasm_simulator (32 qubits) # and plenty of other 5 qubits devices! # # To get a token, create a profile at: # https://quantum-computing.ibm.com/ # device = None # replace by the IBM device name you want to use token = None # replace by the token given by IBMQ if token is None: token = getpass.getpass(prompt='IBM Q token > ') if device is None: device = getpass.getpass(prompt='IBM device > ') # create main compiler engine for the IBM back-end eng = MainEngine(IBMBackend(use_hardware=True, token=token, num_runs=1024, verbose=False, device=device), engine_list=projectq.setups.ibm.get_engine_list( token=token, device=device)) # run the circuit and print the result print(run_entangle(eng))
Returns: measurement (list<int>): List of measurement outcomes. """ # allocate the quantum register to entangle qureg = eng.allocate_qureg(num_qubits) # entangle the qureg Entangle | qureg # measure; should be all-0 or all-1 Measure | qureg # run the circuit eng.flush() # access the probabilities via the back-end: results = eng.backend.get_probabilities(qureg) for state in results: print("Measured {} with p = {}.".format(state, results[state])) # return one (random) measurement outcome. return [int(q) for q in qureg] if __name__ == "__main__": # create main compiler engine for the IBM back-end eng = MainEngine( IBMBackend(use_hardware=True, num_runs=1024, verbose=False)) # run the circuit and print the result print(run_entangle(eng))
class ProjectQContext(object): ''' Context for running circuits. Args: num_bit (int): number of bits in register. task ('ibm'|'draw'|'simulate'): task that decide the environment type. ibm_config (dict): extra arguments for IBM backend. ''' def __init__(self, num_bit, task, ibm_config=None): self.task = task self.num_bit = num_bit self.ibm_config = ibm_config def __enter__(self): ''' Enter context, Attributes: eng (MainEngine): main engine. backend ('graphical' or 'simulate'): backend used. qureg (Qureg): quantum register. ''' if self.task=='ibm': import projectq.setups.ibm else: import projectq.setups.default # create a main compiler engine with a specific backend: if self.task == 'draw': self.backend = CircuitDrawer() # locations = {0: 0, 1: 1, 2: 2, 3:3} # swap order of lines 0-1-2. # self.backend.set_qubit_locations(locations) elif self.task == 'simulate': print('ProjecQ simulation in training can be slow, since in scipy context, we cached a lot gates.') self.backend = Simulator() elif self.task == 'ibm': # choose device device = self.ibm_config.get('device', 'ibmqx2' if self.num_bit<=5 else 'ibmqx5') # check data if self.ibm_config is None: raise if device == 'ibmqx5': device_num_bit = 16 else: device_num_bit = 5 if device_num_bit < self.num_bit: raise AttributeError('device %s has not enough qubits for %d bit simulation!'%(device, self.num_bit)) self.backend = IBMBackend(use_hardware=True, num_runs=self.ibm_config['num_runs'], user=self.ibm_config['user'], password=self.ibm_config['password'], device=device, verbose=True) else: raise ValueError('engine %s not defined' % self.task) self.eng = MainEngine(self.backend) # initialize register self.qureg = self.eng.allocate_qureg(self.num_bit) return self def __exit__(self, exc_type, exc_val, traceback): ''' exit, meanwhile cheat and get wave function. Attributes: wf (1darray): for 'simulate' task, the wave function vector. res (1darray): for 'ibm' task, the measurements output. ''' if traceback is not None: return False if self.task == 'draw': self._viz_circuit() elif self.task == 'simulate': self.eng.flush() order, qvec = self.backend.cheat() self.wf = np.array(qvec) order = [order[i] for i in range(len(self.qureg))] self.wf = np.transpose(self.wf.reshape([2]*len(self.qureg), order='F'), axes=order).ravel(order='F') Measure | self.qureg self.eng.flush() elif self.task == 'ibm': Measure | self.qureg self.eng.flush() self.res = self.backend.get_probabilities(self.qureg) else: raise return self def _viz_circuit(self): Measure | self.qureg self.eng.flush() # print latex code to draw the circuit: s = self.backend.get_latex() # save graph to latex file os.chdir(TEX_FOLDER) with open(TEX_FILENAME, 'w') as f: f.write(s) # texfile = os.path.join(folder, 'circuit-%d.tex'%bench_id) pdffile = TEX_FILENAME[:-3]+'pdf' os.system('pdflatex %s'%TEX_FILENAME) openfile(pdffile)
def main(): args = _define_args() args = args.parse_args() _check(args) fin = args.infile fout = args.outfile engines = ibm.get_engine_list() # remove the CNot flipper if not args.ibm: engines = engines[:-2] + engines[-1:] print('Converting...') else: print('Converting for IBM Q Experience...') if args.on_hardware: print('We will run the converted code on the IBM device {}\n.'.format( args.ibm)) backend = IBMBackend(use_hardware=True, device=args.ibm, num_runs=args.n) elif args.s: print('We will run the converted code on the IBM simulator\n.') backend = IBMBackend(use_hardware=False, device=args.ibm, num_runs=args.n) else: # backend similar to IBMBackend creating qasm code but without running it backend = GetQASMBackend() eng = MainEngine(backend=backend, engine_list=engines) s = fin.read() fin.close() # parse input root = grammar.parse(s) # create visitor that transforms tree into gate list visitor = ToGateListVisitor() # pass root of parsed tree to visitor gate_list = visitor.visit(root) #gate_list=flatten_touples(gate_list) # create circuit from gate_list nb_qubits = build_circuit(gate_list, eng) # create qasm code qasm = get_qasm(eng, nb_qubits) if fout == sys.stdout: print(5 * '=' + ' OpenQASM code ' + 5 * '=') fout.write(qasm) if fout != sys.stdout: print('OpenQASM output saved to {}'.format(fout.name)) print() if hasattr(backend, 'get_probabilities'): print(5 * '=' + ' Results from {} run on hardware '.format(args.n) + 5 * '=') for k, v in sorted(backend.get_probabilities(qureg).items()): print('Probability for state |{}>: {}'.format(k, v))
molecule = run_pyscf(molecule, run_scf=run_scf, run_mp2=run_mp2, run_cisd=run_cisd, run_ccsd=run_ccsd, run_fci=run_fci) # Use a Jordan-Wigner encoding, and compress to remove 0 imaginary components qubit_hamiltonian = jordan_wigner(molecule.get_molecular_hamiltonian()) qubit_hamiltonian.compress() # compiler_engine = uccsd_trotter_engine(CommandPrinter()) compiler_engine = uccsd_trotter_engine( compiler_backend=IBMBackend(user="******", password="******", use_hardware=False, num_runs=1024, verbose=False)) n_amplitudes = uccsd_singlet_paramsize(molecule.n_qubits, molecule.n_electrons) initial_amplitudes = [0.01] * n_amplitudes energy_objective(initial_amplitudes) # # Run VQE Optimization to find new CCSD parameters # opt_result = minimize(energy_objective, initial_amplitudes, # method="CG", options={'disp':True}) # # opt_energy, opt_amplitudes = opt_result.fun, opt_result.x # # print("\n Results for {}:".format(molecule.name)) # print("Optimal UCCSD Singlet Energy: {}".format(opt_energy))
parser.add_argument("--number", action="store", default=10, dest="input_number", help="select the number to factor") myarg = parser.parse_args() # GET VARIABLES FROM CK_ENV verbose = os.getenv('CK_VERBOSE', False) ibm_device = os.getenv('CK_PROJECTQ_IBM_DEVICE', "IBM_OFF") print(ibm_device) if ibm_device in ["ibmqx2", "ibmqx4", "ibmqx5"]: print("IBM Backend") eng = MainEngine(IBMBackend(use_hardware=False, num_runs=1, device=ibm_device), setup=projectq.setups.ibm) else: # make the compiler and run the circuit on the simulator backend eng = MainEngine(Simulator(gate_fusion=False), compilerengines) # print welcome message and ask the user for the number to factor print( "\n\t\033[37mprojectq\033[0m\n\t--------\n\tImplementation of Shor" "\'s algorithm.", end="") # N = int(input('\n\tNumber to factor: ')) N = int(myarg.input_number) print("\n\tFactoring N = {}: \033[0m".format(N), end="")
from projectq.ops import H, Measure, StatePreparation from projectq import MainEngine import projectq.setups.ibm from projectq.backends import IBMBackend #Intialization ME = MainEngine(IBMBackend(), projectq.setups.ibm.get_engine_list()) rand_list = [] #random integer generation using 1 qubit and Hadamard gate def getrandomquantum(mainengine): qubit = mainengine.allocate_qubit() H | qubit Measure | qubit rand_int = int(qubit) rand_list.append(rand_int) for i in range(10): getrandomquantum(ME) #Flush gates ME.flush() print(rand_list)
import math, numpy, random, time, getpass # normal python stuff from projectq import MainEngine # import the main compiler engine from projectq.ops import H, S, T, X, CNOT, Entangle, get_inverse, Measure # import the operations we want to perform import projectq.setups.ibm from projectq.backends import IBMBackend eng = MainEngine( IBMBackend(use_hardware=True, num_runs=1024, verbose=False, user=None, password=None)) print("\n\n\n\n===== Welcome to Quantum Battleships! =====\n\n") print(" ~~ A game by the Decodoku project ~~ ") print("\n\n") print("When in doubt, press any key to continue!") raw_input() print("This is a game for two players.") raw_input() print("Player 1 will choose the position of a Battleship.") raw_input() print("Player 2 will try to bomb it.") raw_input() # get player 1 to position boat print("We start with Player 1.") print("Look away Player 2!") raw_input()
import os from pathlib import Path import projectq.setups.ibm # Imports the default compiler to map to IBM QE from dotenv import load_dotenv from projectq.backends import IBMBackend from projectq.ops import All, Entangle, Measure from projectq import MainEngine try: current_path = Path('.') / '.env' load_dotenv(current_path) token = os.environ['IBM_QUANTUM_API_KEY'] device = device = 'ibmq_rome' compiler_engines = projectq.setups.ibm.get_engine_list(token=token, device=device) engine = MainEngine(IBMBackend(token=token, use_hardware=True, num_runs=1024, verbose=True, device=device), engine_list=compiler_engines) qureg = engine.allocate_qureg(3) Entangle | qureg All(Measure) | qureg engine.flush() print([int(q) for q in qureg]) except KeyError: print("Please define the environment variables: IBM_QUANTUM_API_KEY")