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
def compute_winner(self): """Find overall game winner, by finding winners of each outcome""" self.c.size = self.q.size #Make them the same self.qc.measure(self.q, self.c) #Measure backend = Aer.get_backend('qasm_simulator') job_sim = execute(self.qc, backend=backend, shots=100) sim_result = job_sim.result() print("simulation: ", sim_result) print(sim_result.get_counts(self.qc)) self.counts = sim_result.get_counts(self.qc) for count in self.counts: #Takes key names c = list(count)[:-1] #splits key '1011' => ['1','0','1','1'] c = c[::-1] #invert it so it goes 0 up... #Ignore the last bit since I dont know how to get rid of it #It is zero always. #The reason it is included is that I create a quantum register and #then start adding operations, quantum registers need at least one bit. counter = 0 weight = self.counts[count] empty = np.zeros((self.x,self.y),dtype=str) for m in self.moves: if m.player == 0: char = 'x' elif m.player==1: char = 'o' result = [] if m.q1: result.append(c[counter]) counter+=1 if m.q2: result.append(c[counter]) counter+=1 #print(result) if len(result) == len(m.indices): #print(m) if result[0]=='1': empty[m.indices[0][0],m.indices[0][1]] = char if len(result)>1: if result[1]=='1': if result[0]=='1': print('problem! a move appeard in two places.') print(m) empty[m.indices[1][0],m.indices[1][1]] = char elif not result: #Then it was a classcal move empty[m.indices[0][0],m.indices[0][1]] = char xscore,oscore=self.winners(empty) print('X wins: '+str(xscore)) print('O wins: '+str(oscore)) print('Shots: '+str(weight)) print(empty)
def evaluate_circuit(gamma_beta, qr, p): n = len(gamma_beta)//2 circuit = create_circuit(qr, gamma_beta[:n], gamma_beta[n:], p) return np.real(Hc.eval("matrix", circuit, Aer.get_backend('statevector_simulator'))[0])
# -*- coding: utf-8 -*- """ Created on Mon May 20 21:07:00 2019 @author: hnorlen """ from qiskit import QuantumCircuit, Aer, execute from qiskit.visualization import plot_histogram from IPython.core.display import display print("Ch 5: Upside down quantum coin toss") print("-----------------------------------") qc = QuantumCircuit(1, 1) initial_vector = [0. + 0.j, 1. + 0.j] qc.initialize(initial_vector, 0) #qc.x(0) qc.h(0) qc.measure(0, 0) print(qc) #display(qc.draw()) backend = Aer.get_backend('qasm_simulator') counts = execute(qc, backend, shots=1).result().get_counts(qc) display(plot_histogram(counts))
from qiskit.transpiler import passes from qiskit.test.mock import FakeMelbourne from qiskit.transpiler.passes import CrosstalkAdaptiveSchedule from qiskit.converters import circuit_to_dag, dag_to_circuit from qiskit.transpiler import Layout from z3 import Real, Bool, Sum, Implies, And, Or, Not, Optimize import logging from numpy import pi # with open(sys.argv[1],'r') as f: # contents = f.read() f= sys.argv[1] print(f) #quit() backend = FakeMelbourne() #print(Aer.backends()) backend2 = Aer.get_backend('statevector_simulator') #quit() qreg_q = QuantumRegister(14, 'q') crosstalk_prop={} crosstalk_prop[(0,1)]={(2,3):0.9} crosstalk_prop[(2,3)]={(0,1):0.9} #crosstalk_prop[(5,6)]={(8,9):0.2} crosstalk_prop[(8,9)]={(10,11):0.9} crosstalk_prop[(10,11)]={(8,9):0.9} circuit = QuantumCircuit(14, 14) #circuit = QuantumCircuit.from_qasm_file('') circuit = QuantumCircuit.from_qasm_file(f'/Users/feihua/pythonfile/516projectcode/circuits/large/{f}') # circuit.x(qreg_q[0]) # circuit.x(qreg_q[2]) # circuit.h(qreg_q[0]) # circuit.cu1(pi/2, qreg_q[1], qreg_q[0])
def sys_evolve(nsites, excitations, total_time, dt, hop, U, trotter_steps): #Check for correct data types of input if not isinstance(nsites, int): raise TypeError("Number of sites should be int") if np.isscalar(excitations): raise TypeError("Initial state should be list or numpy array") if not np.isscalar(total_time): raise TypeError("Evolution time should be scalar") if not np.isscalar(dt): raise TypeError("Time step should be scalar") if not isinstance(trotter_steps, int): raise TypeError("Number of trotter slices should be int") numq = 2 * nsites num_steps = int(total_time / dt) print('Num Steps: ', num_steps) print('Total Time: ', total_time) data = np.zeros((2**numq, num_steps)) for t_step in range(0, num_steps): #Create circuit with t_step number of steps q = QuantumRegister(numq) c = ClassicalRegister(numq) qcirc = QuantumCircuit(q, c) #=========USE THIS REGION TO SET YOUR INITIAL STATE============== #Loop over each excitation for flip in excitations: qcirc.x(flip) # qcirc.z(flip) #=============================================================== qcirc.barrier() #Append circuit with Trotter steps needed qc_evolve(qcirc, nsites, t_step * dt, dt, hop, U, trotter_steps) #Measure the circuit for i in range(numq): qcirc.measure(i, i) #Choose provider and backend #provider = IBMQ.get_provider() #backend = Aer.get_backend('statevector_simulator') backend = Aer.get_backend('qasm_simulator') #backend = provider.get_backend('ibmq_qasm_simulator') #backend = provider.get_backend('ibmqx4') #backend = provider.get_backend('ibmqx2') #backend = provider.get_backend('ibmq_16_melbourne') shots = 8192 max_credits = 10 #Max number of credits to spend on execution job_exp = execute(qcirc, backend=backend, shots=shots, max_credits=max_credits) job_monitor(job_exp) result = job_exp.result() counts = result.get_counts(qcirc) print(result.get_counts(qcirc)) print("Job: ", t_step + 1, " of ", num_steps, " complete.") #Store results in data array and normalize them for i in range(2**numq): if counts.get(get_bin(i, numq)) is None: dat = 0 else: dat = counts.get(get_bin(i, numq)) data[i, t_step] = dat / shots return data
%matplotlib inline # Importing standard Qiskit libraries and configuring account from qiskit import QuantumCircuit, execute, Aer, IBMQ from qiskit.compiler import transpile, assemble from qiskit.tools.jupyter import * from qiskit.visualization import * # Loading your IBM Q account(s) provider = IBMQ.load_account() from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, execute, Aer import numpy as np import math as m S_simulator = Aer.backends(name='statevector_simulator')[0] M_simulator = Aer.backends(name='qasm_simulator')[0] q = QuantumRegister(1) test_qubit = QuantumCircuit(q) # Got a minus/zero vector by default. # q6_0: |0> test_qubit.iden(q[0]) # Applying identity matrix on zero vector. # ┌────┐ # q6_0: |0>┤ Id ├ # └────┘ # Passing the circuit that we want to execute that is Identy gate on zero vector. # Parameter#1 The circuit that is identity vector applied on zero vector. # Parameter#2 statevector_simulator # Applying x gate on zero vector. # ┌───┐ # q10_0: |0>┤ X ├ # └───┘
def test_random_circuit_generator_qiskit_comparison(): gates_c = ["circuit.i({})", \ "circuit.x({})", \ "circuit.y({})", \ "circuit.z({})", \ "circuit.h({})", \ "circuit.t({})", \ "circuit.cx({}, {})", \ "circuit.cy({}, {})", \ "circuit.cz({}, {})", \ "circuit.ch({}, {})", \ "circuit.swap({}, {})", \ #"circuit.rx({}, {})", \ #"circuit.ry({}, {})", \ #"circuit.rz({}, {})", \ "circuit.rot({}, {})", \ "circuit.crot({}, {}, {})"] gates_qkit = ["qubit.iden(q_reg[{}])", \ "qubit.x(q_reg[{}])", \ "qubit.y(q_reg[{}])", \ "qubit.z(q_reg[{}])", \ "qubit.h(q_reg[{}])", \ "qubit.t(q_reg[{}])", \ "qubit.cx(q_reg[{}], q_reg[{}])", \ "qubit.cy(q_reg[{}], q_reg[{}])", \ "qubit.cz(q_reg[{}], q_reg[{}])", \ "qubit.ch(q_reg[{}], q_reg[{}])", \ "qubit.swap(q_reg[{}], q_reg[{}])", \ #"qubit.rx({}, q_reg[{}])", \ #"qubit.ry({}, q_reg[{}])", \ #"qubit.rz({}, q_reg[{}])", \ "qubit.u1({}, q_reg[{}])", \ "qubit.cu1({},q_reg[{}], q_reg[{}])"] gate_type = [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 4] #gate_type = [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4] func_len = len(gates_c) S_simulator = Aer.backends(name='statevector_simulator')[0] #errors = 0 # number of circuits generated for _ in range(n_of_circuits_generated): n_qbit = random.randrange(2, 21) circuit = qcs.circuit_init(n_qbit) q_reg = QuantumRegister(n_qbit) qubit = QuantumCircuit(q_reg) # number of gates on circuit for _ in range(n_of_gates_per_circuit): q = random.randrange(0, n_qbit - 1) gate_choice = random.randrange(0, func_len) my_gate = gates_c[gate_choice] qiskit_gate = gates_qkit[gate_choice] gtype = gate_type[gate_choice] # single gate if (gtype == 1): exec(my_gate.format(q)) exec(qiskit_gate.format(q)) # controlled gate elif (gtype == 2): side = random.choice(["up", "down"]) if (q == n_qbit - 1): q = q - 1 if side == "up": exec(my_gate.format(q, q + 1)) exec(qiskit_gate.format(q, q + 1)) if side == "down": exec(my_gate.format(q + 1, q)) exec(qiskit_gate.format(q + 1, q)) # rotation gates if (gtype == 3): angle = random.uniform(-np.pi, np.pi) exec(my_gate.format(q, angle)) exec(qiskit_gate.format(angle, q)) # controlled rotation gate elif (gtype == 4): angle = random.uniform(-np.pi, np.pi) side = random.choice(["up", "down"]) if (q == n_qbit - 1): q = q - 1 if side == "up": exec(my_gate.format(q, q + 1, angle)) exec(qiskit_gate.format(angle, q, q + 1)) if side == "down": exec(my_gate.format(q + 1, q, angle)) exec(qiskit_gate.format(angle, q + 1, q)) # getting and comparing results result = circuit.execute(probs_autocalc=False) sv = result.get_state_vector() job = execute(qubit, S_simulator) result_qkit = job.result() sv_qkit = result_qkit.get_statevector() assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8, rtol=1e-8) \ == None
class QCircuitMachine(RuleBasedStateMachine): """Build a Hypothesis rule based state machine for constructing, transpiling and simulating a series of random QuantumCircuits. Build circuits with up to QISKIT_RANDOM_QUBITS qubits, apply a random selection of gates from qiskit.circuit.library with randomly selected qargs, cargs, and parameters. At random intervals, transpile the circuit for a random backend with a random optimization level and simulate both the initial and the transpiled circuits to verify that their counts are the same. """ qubits = Bundle("qubits") clbits = Bundle("clbits") backend = Aer.get_backend("qasm_simulator") max_qubits = int(backend.configuration().n_qubits / 2) def __init__(self): super().__init__() self.qc = QuantumCircuit() @precondition(lambda self: len(self.qc.qubits) < self.max_qubits) @rule(target=qubits, n=st.integers(min_value=1, max_value=max_qubits)) def add_qreg(self, n): """Adds a new variable sized qreg to the circuit, up to max_qubits.""" n = min(n, self.max_qubits - len(self.qc.qubits)) qreg = QuantumRegister(n) self.qc.add_register(qreg) return multiple(*list(qreg)) @rule(target=clbits, n=st.integers(1, 5)) def add_creg(self, n): """Add a new variable sized creg to the circuit.""" creg = ClassicalRegister(n) self.qc.add_register(creg) return multiple(*list(creg)) # Gates of various shapes @rule(gate=st.sampled_from(oneQ_gates), qarg=qubits) def add_1q_gate(self, gate, qarg): """Append a random 1q gate on a random qubit.""" self.qc.append(gate(), [qarg], []) @rule( gate=st.sampled_from(twoQ_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True), ) def add_2q_gate(self, gate, qargs): """Append a random 2q gate across two random qubits.""" self.qc.append(gate(), qargs) @rule( gate=st.sampled_from(threeQ_gates), qargs=st.lists(qubits, max_size=3, min_size=3, unique=True), ) def add_3q_gate(self, gate, qargs): """Append a random 3q gate across three random qubits.""" self.qc.append(gate(), qargs) @rule( gate=st.sampled_from(oneQ_oneP_gates), qarg=qubits, param=st.floats( allow_nan=False, allow_infinity=False, min_value=-10 * pi, max_value=10 * pi, allow_subnormal=False, ), ) def add_1q1p_gate(self, gate, qarg, param): """Append a random 1q gate with 1 random float parameter.""" self.qc.append(gate(param), [qarg]) @rule( gate=st.sampled_from(oneQ_twoP_gates), qarg=qubits, params=st.lists( st.floats( allow_nan=False, allow_infinity=False, min_value=-10 * pi, max_value=10 * pi, allow_subnormal=False, ), min_size=2, max_size=2, ), ) def add_1q2p_gate(self, gate, qarg, params): """Append a random 1q gate with 2 random float parameters.""" self.qc.append(gate(*params), [qarg]) @rule( gate=st.sampled_from(oneQ_threeP_gates), qarg=qubits, params=st.lists( st.floats( allow_nan=False, allow_infinity=False, min_value=-10 * pi, max_value=10 * pi, allow_subnormal=False, ), min_size=3, max_size=3, ), ) def add_1q3p_gate(self, gate, qarg, params): """Append a random 1q gate with 3 random float parameters.""" self.qc.append(gate(*params), [qarg]) @rule( gate=st.sampled_from(twoQ_oneP_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True), param=st.floats( allow_nan=False, allow_infinity=False, min_value=-10 * pi, max_value=10 * pi, allow_subnormal=False, ), ) def add_2q1p_gate(self, gate, qargs, param): """Append a random 2q gate with 1 random float parameter.""" self.qc.append(gate(param), qargs) @rule( gate=st.sampled_from(twoQ_threeP_gates), qargs=st.lists(qubits, max_size=2, min_size=2, unique=True), params=st.lists( st.floats( allow_nan=False, allow_infinity=False, min_value=-10 * pi, max_value=10 * pi, allow_subnormal=False, ), min_size=3, max_size=3, ), ) def add_2q3p_gate(self, gate, qargs, params): """Append a random 2q gate with 3 random float parameters.""" self.qc.append(gate(*params), qargs) @rule(gate=st.sampled_from(oneQ_oneC_gates), qarg=qubits, carg=clbits) def add_1q1c_gate(self, gate, qarg, carg): """Append a random 1q, 1c gate.""" self.qc.append(gate(), [qarg], [carg]) @rule(gate=st.sampled_from(variadic_gates), qargs=st.lists(qubits, min_size=1, unique=True)) def add_variQ_gate(self, gate, qargs): """Append a gate with a variable number of qargs.""" self.qc.append(gate(len(qargs)), qargs) @precondition(lambda self: len(self.qc.data) > 0) @rule(carg=clbits, data=st.data()) def add_c_if_last_gate(self, carg, data): """Modify the last gate to be conditional on a classical register.""" creg = carg.register val = data.draw(st.integers(min_value=0, max_value=2 ** len(creg) - 1)) last_gate = self.qc.data[-1] # Conditional instructions are not supported assume(isinstance(last_gate[0], Gate)) last_gate[0].c_if(creg, val) # Properties to check @invariant() def qasm(self): """After each circuit operation, it should be possible to build QASM.""" self.qc.qasm() @precondition(lambda self: any(isinstance(d[0], Measure) for d in self.qc.data)) @rule( backend=st.one_of(st.none(), st.sampled_from(mock_backends)), opt_level=st.integers(min_value=0, max_value=3), ) def equivalent_transpile(self, backend, opt_level): """Simulate, transpile and simulate the present circuit. Verify that the counts are not significantly different before and after transpilation. """ print(f"Evaluating circuit at level {opt_level} on {backend}:\n{self.qc.qasm()}") assume(backend is None or backend.configuration().n_qubits >= len(self.qc.qubits)) shots = 4096 aer_counts = execute(self.qc, backend=self.backend, shots=shots).result().get_counts() try: xpiled_qc = transpile(self.qc, backend=backend, optimization_level=opt_level) except Exception as e: failed_qasm = "Exception caught during transpilation of circuit: \n{}".format( self.qc.qasm() ) raise RuntimeError(failed_qasm) from e xpiled_aer_counts = ( execute(xpiled_qc, backend=self.backend, shots=shots).result().get_counts() ) count_differences = dicts_almost_equal(aer_counts, xpiled_aer_counts, 0.05 * shots) assert count_differences == "", "Counts not equivalent: {}\nFailing QASM: \n{}".format( count_differences, self.qc.qasm() )
from qiskit import Aer from qiskit import IBMQ for backend in Aer.backends(): print(backend.name()) for backend in IBMQ.providers(): print(backend.name())
def minicomposer(nqubits=5, bloch=False, dirac=False, qsphere=False): out = widgets.Output single_gates = ['I', 'X', 'Y', 'Z', 'H', 'T', 'Tdg', 'S', 'Sdg'] multi_gates = ['CX', 'CZ', 'SWAP'] qc = QuantumCircuit(nqubits) if bloch or dirac or qsphere: backend = Aer.get_backend('statevector_simulator') class CircuitWidget: def __init__(self): self.waiting_for = 'gate' self.current_gate = '' self.qubits = [''] self.code = "" self.statevec = [] widget_state = CircuitWidget() cell_pretext = """def create_circuit():\n qc = QuantumCircuit({})\n""".format( nqubits) cell_ending = " return qc" def on_sqg_click(btn): """On single-qubit-gate button click""" if widget_state.waiting_for == 'gate': widget_state.waiting_for = 'sqg_qubit' update_output() widget_state.current_gate = btn.description def on_mqg_click(btn): """On multi-qubit-gate button click""" if widget_state.waiting_for == 'gate': widget_state.waiting_for = 'mqg_qubit_0' update_output() widget_state.current_gate = btn.description def on_qubit_click(btn): """On qubit button click""" if widget_state.waiting_for == 'sqg_qubit': widget_state.qubits[0] = int(btn.description) apply_gate() widget_state.waiting_for = 'gate' update_output() elif widget_state.waiting_for == 'mqg_qubit_0': widget_state.qubits[0] = int(btn.description) widget_state.waiting_for = 'mqg_qubit_1' update_output() elif widget_state.waiting_for == 'mqg_qubit_1': widget_state.qubits.append(int(btn.description)) widget_state.waiting_for = 'gate' apply_gate() update_output() def on_clear_click(btn): """On Clear button click""" widget_state.current_gate = 'Clear' widget_state.waiting_for = 'gate' apply_gate() update_output() def apply_gate(): """Uses widget_state to apply the last selected gate, update the code cell and prepare widget_state for the next selection""" functionmap = { 'I': 'qc.iden', 'X': 'qc.x', 'Y': 'qc.y', 'Z': 'qc.z', 'H': 'qc.h', 'S': 'qc.s', 'T': 'qc.t', 'Sdg': 'qc.sdg', 'Tdg': 'qc.tdg', 'CX': 'qc.cx', 'CZ': 'qc.cz', 'SWAP': 'qc.swap' } gate = widget_state.current_gate qubits = widget_state.qubits widget_state.code += " " if len(qubits) == 2: widget_state.code += functionmap[gate] widget_state.code += "({0}, {1})\n".format(qubits[0], qubits[1]) widget_state.qubits.pop() elif widget_state.current_gate == 'Clear': widget_state.code = "" else: widget_state.code += functionmap[gate] + "({})\n".format(qubits[0]) qc = QuantumCircuit(nqubits) # This is especially awful I know, please don't judge me exec(widget_state.code.replace(" ", "")) qc.draw('mpl').savefig('circuit_widget_temp.svg', format='svg') if bloch or dirac or qsphere: ket = execute(qc, backend).result().get_statevector() if bloch: plot_bloch_multivector(ket, show_state_labels=True).savefig( 'circuit_widget_temp_bs.svg', format='svg') if qsphere: plot_state_qsphere(ket, show_state_labels=True).savefig( 'circuit_widget_temp_qs.svg', format='svg') if dirac: widget_state.statevec = ket # Create buttons for single qubit gates sqg_btns = [widgets.Button(description=gate) for gate in single_gates] # Link these to the on_sqg_click function for button in sqg_btns: button.on_click(on_sqg_click) # Create buttons for qubits qubit_btns = [ widgets.Button(description=str(qubit)) for qubit in range(nqubits) ] # Register these too for button in qubit_btns: button.on_click(on_qubit_click) # Create & register buttons for multi-qubit gates, clear mqg_btns = [widgets.Button(description=gate) for gate in multi_gates] for button in mqg_btns: button.on_click(on_mqg_click) clear_btn = widgets.Button(description="Clear") clear_btn.on_click(on_clear_click) instruction = widgets.Label(value="Select a gate to add to the circuit:") qc.draw('mpl').savefig('circuit_widget_temp.svg', format='svg') if bloch or dirac or qsphere: ket = execute(qc, backend).result().get_statevector() if bloch: plot_bloch_multivector(ket).savefig('circuit_widget_temp_bs.svg', format='svg') with open('circuit_widget_temp_bs.svg', 'r') as img: bloch_sphere = widgets.HTML(value=img.read()) if qsphere: plot_state_qsphere(ket).savefig('circuit_widget_temp_qs.svg', format='svg') with open('circuit_widget_temp_qs.svg', 'r') as img: qsphere = widgets.HTML(value=img.read()) if dirac: widget_state.statevec = ket latex_statevec = widgets.HTMLMath(vec_in_text_braket(ket)) qiskit_code = widgets.HTML(value='') with open('circuit_widget_temp.svg', 'r') as img: drawing = widgets.HTML(value=img.read()) def display_widget(): sqg_box = widgets.HBox(sqg_btns) mqg_box = widgets.HBox(mqg_btns + [clear_btn]) qubit_box = widgets.HBox(qubit_btns) main_box = widgets.VBox([sqg_box, mqg_box, qubit_box]) visuals = [drawing] if bloch: visuals.append(bloch_sphere) if qsphere: visuals.append(qsphere) if dirac: visuals.append(latex_statevec) vis_box = widgets.VBox(visuals) display(instruction, main_box, vis_box) display(qiskit_code) def update_output(): """Changes the availability of buttons depending on the state of widget_state.waiting_for, updates displayed image""" if widget_state.waiting_for == 'gate': for button in sqg_btns: button.disabled = False for button in mqg_btns: if nqubits > 1: button.disabled = False else: button.disabled = True for button in qubit_btns: button.disabled = True instruction.value = "Select a gate to add to the circuit:" else: for button in sqg_btns: button.disabled = True for button in mqg_btns: button.disabled = True for button in qubit_btns: button.disabled = False if widget_state.waiting_for == 'sqg_qubit': instruction.value = "Select a qubit to perform the gate on:" elif widget_state.waiting_for == 'mqg_qubit_0': instruction.value = "Select the control qubit:" elif widget_state.waiting_for == 'mqg_qubit_1': instruction.value = "Select the target qubit:" qubit_btns[widget_state.qubits[0]].disabled = True with open('circuit_widget_temp.svg', 'r') as img: drawing.value = img.read() if bloch: with open('circuit_widget_temp_bs.svg', 'r') as img: bloch_sphere.value = img.read() if qsphere: with open('circuit_widget_temp_qs.svg', 'r') as img: qsphere.value = img.read() if dirac: latex_statevec.value = vec_in_text_braket(widget_state.statevec) complete_code = cell_pretext + widget_state.code + cell_ending qiskit_code.value = f""" <div class="output_html" style="line-height: 1.21429em; font-size: 14px"> {Code(complete_code, language='python')._repr_html_()} </div> """ display_widget() update_output()
qc = QuantumCircuit(q, c) qc.h(q[0]) qc.rx(w[0], q[0]) qc.rx(w[1], q[1]) qc.rx(w[2], q[2]) qc.ry(w[3], q[0]) qc.ry(w[4], q[1]) qc.ry(w[5], q[2]) qc.rz(w[6], q[0]) qc.rz(w[7], q[1]) qc.rz(w[8], q[2]) qc.cx(q[0], q[1]) qc.cx(q[1], q[2]) qc.rx(w[9], q[0]) qc.ry(w[10], q[0]) qc.rz(w[11], q[0]) qc.rx(w[12], q[1]) qc.ry(w[13], q[1]) qc.rz(w[14], q[1]) # - job = execute(qc, backend=Aer.get_backend("statevector_simulator")) vec = job.result().get_statevector() for i in vec: print(i)
# Gets IBMQ providers IBMQ.providers() provider = IBMQ.get_provider("ibm-q") # Tells us the queue length and qubit availability of all the backends for backend in provider.backends(): try: qubit_count = len(backend.properties().qubits) except: qubit_count = "simulated" print( f"{backend.name()} has {backend.status().pending_jobs} queued and {qubit_count} qubits" ) # Simulator backend for backend in Aer.backends(): print(backend) # Choose a specific backend simulator_backend = Aer.get_backend('qasm_simulator') backend = provider.get_backend("ibmq_athens") backend_online_sim = provider.get_backend("ibmq_qasm_simulator") ''' Run Simulation Through Backend ''' job = q.execute(circuit, backend=backend_online_sim, shots=500) job_monitor(job) # Plot Results result = job.result()
# \end{pmatrix}$ # In[2]: # Let's do an X-gate on a |0> qubit q = QuantumRegister(1) qc = QuantumCircuit(q) qc.x(q[0]) qc.draw(output='mpl') # Note: There is a new syntax that omits `Quantum Register` , but in this challenge, we will use the above syntax because it is easier to understand the algorithms of complex quantum circuits. (You can see the new notation [here](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.html?highlight=quantumcircuit#qiskit.circuit.QuantumCircuit).) # In[3]: # Let's see the result backend = Aer.get_backend('statevector_simulator') result = execute(qc, backend).result().get_statevector(qc, decimals=3) plot_bloch_multivector(result) # ### H Gate # A Hadamard gate represents a rotation of $\pi$ about the axis that is in the middle of the $X$-axis and $Z$-axis. # It maps the basis state $|0\rangle$ to $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$, which means that a measurement will have equal probabilities of being `1` or `0`, creating a 'superposition' of states. This state is also written as $|+\rangle$. # # $H = \frac{1}{\sqrt{2}}\begin{pmatrix} # 1 & 1 \\ # 1 & -1 \\ # \end{pmatrix}$ # In[4]: # Let's do an H-gate on a |0> qubit
def run_simulation (system, indx, commandprinter = False, noise = False): def vqe_create_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, z2_symmetries, initial_point = system.opt_amplitudes, noise = noise): initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list) var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=z2_symmetries) if noise: var_form = EfficientSU2(num_qubits = no_qubits, entanglement="linear") else: var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=z2_symmetries) vqe = VQE(var_form=var_form, optimizer=SLSQP(maxiter=500), include_custom=True, initial_point = initial_point) vqe.quantum_instance = backend return vqe basis_string = 'sto-3g' charge = 0 spin = 1 no_qubits = 6 if noise: optimizer = SPSA(maxiter=100) IBMQ.load_account() provider = IBMQ.get_provider(hub='ibm-q') qasm = Aer.get_backend("qasm_simulator") device = provider.get_backend("ibmq_16_melbourne") coupling_map = device.configuration().coupling_map noise_model = NoiseModel.from_backend(device.properties()) backend = QuantumInstance(backend=qasm, shots=10000, noise_model=noise_model, coupling_map=coupling_map, measurement_error_mitigation_cls=CompleteMeasFitter, cals_matrix_refresh_period=30) else: optimizer = SLSQP(maxiter=500) backend = Aer.get_backend('qasm_simulator') ######################################################################## # Begin Running Simulation, Convert distance_counter to angstroms geometry = ['H 0. 0. ' + str(system.atoms[0].position[-1] * 0.529177249), 'H 0. 0. ' + str(system.atoms[1].position[-1] * 0.529177249), 'H 0. 0. ' + str(system.atoms[2].position[-1] * 0.529177249)] if indx is not None: geometry[indx] = 'H 0. 0. ' + str(system.atoms[indx].stand_by_position * 0.529177249) print(geometry) driver = PySCFDriver(atom=geometry, unit=UnitsType.ANGSTROM, charge=charge, spin=spin, basis=basis_string) # # # # # # # # # # # # # # # # # # # # # # # VQE Result # # # # # # # # # # # # # # # # # # # # # # mgse = MolecularGroundStateEnergy(driver, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=False, z2symmetry_reduction=None) vqe_result = mgse.compute_energy(vqe_create_solver).energy system.opt_amplitudes = mgse.solver.optimal_params # # # # # # # # # # # # # # # # # # # # # # # Exact Result # # # # # # # # # # # # # # # # # # # # # # mgse = MolecularGroundStateEnergy(driver, NumPyMinimumEigensolver(), qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=False, z2symmetry_reduction=None) exact_result = mgse.compute_energy().energy print("VQE Result:", vqe_result, "Exact Energy:", exact_result) return ({"Exact Energy" : exact_result, "VQE Energy" : vqe_result})
def get_simulator(self): return Aer.get_backend('qasm_simulator')
def Mont_Mul(x, y, m): n = len(x) x_reg = QuantumRegister(n + 1) y_reg = QuantumRegister(n + 2) y_reg_0 = QuantumRegister(1) m_reg = QuantumRegister(n + 2) a_reg = QuantumRegister(n + 2) u_reg = QuantumRegister(n + 1) onecubit = QuantumRegister(1) a_cl_reg = ClassicalRegister(n + 2) u_cl_reg = ClassicalRegister(n + 1) cl_reg = ClassicalRegister(n + 1) one_cl_reg = ClassicalRegister(1) circ_u = QuantumCircuit(u_reg, y_reg_0, u_cl_reg) circ_a = QuantumCircuit(a_reg, y_reg, m_reg, a_cl_reg, onecubit, one_cl_reg) if y[n - 1] == '1': circ_u.x(y_reg_0) for i in range(n): if y[i] == '1': circ_a.x(y_reg[n - i - 1]) for i in range(n): if m[i] == '1': circ_a.x(m_reg[n - i - 1]) for i in range(n): if x[n - i - 1] == '1': add(u_reg, y_reg_0, circ_u) circ_u.measure(u_reg[0], u_cl_reg[0]) result = execute(circ_u, backend=Aer.get_backend('qasm_simulator'), shots=2).result().get_counts(circ_u) measure_u = int((list(result.keys())[0])) if x[n - i - 1] == '1': add(a_reg, y_reg, circ_a) if measure_u == 1: add(a_reg, m_reg, circ_a) rshift(circ_a, a_reg, n + 2, onecubit) circ_a.measure(a_reg, a_cl_reg) circ_a.measure(onecubit, one_cl_reg) result = execute(circ_a, backend=Aer.get_backend('qasm_simulator'), shots=2).result().get_counts(circ_a) total = list(result.keys())[0] measure_a = total[2:] measure_onecubit = int(total[0]) if measure_onecubit == 1: circ_a.x(onecubit) # loading a0 to u0 if measure_a[n + 1] == '1': if measure_u == 0: circ_u.x(u_reg[0]) else: if measure_u == 1: circ_u.x(u_reg[0]) if (int(measure_a) >= int(m)): sub(a_reg, m_reg, circ_a) circ_a.measure(a_reg, a_cl_reg) result = execute(circ_a, backend=Aer.get_backend('qasm_simulator'), shots=2).result().get_counts(circ_a) total = list(result.keys())[0] final_a = total[2:] return final_a
def phase_estimation(U: Callable[[QuantumCircuit, int, int], QuantumCircuit], bits: int, show: bool = True, shots: int = 2048) -> Tuple[float, QuantumCircuit]: """ Estimates θ, given a unitary operator U, such that U|ψ} = e^(2πiθ)|ψ} U: A function that adds controlled unitary gates to a given circuit, and returns the circuit bits: bit-size of phase estimation circuit (excluding ψ) show: if True, displays circuit and histogram of results (Jupyter notebook only) shots: number of shots (runs) to be executed Returns the tuple: (estimated theta, quantum estimation circuit) """ backend = Aer.get_backend('qasm_simulator') # q = QuantumCircuit(bits+1, bits) qr = QuantumRegister(bits, 'q') psi = QuantumRegister(1, 'psi') cr = ClassicalRegister(bits, 'c') q = QuantumCircuit(qr, psi, cr) # Apply Unitaries q.x(bits) # Initialize |ψ} for i in range(bits): q.h(i) for _ in range(2**i): q = U(q, bits, i) # apply controlled unitary q.barrier() # Inverse QFT swapped = [] for a, b in enumerate(range(bits)[::-1]): if (a == b) or (a in swapped) or (b in swapped): break q.swap(a, b) # swap bits swapped += [a, b] for i in range(bits): # apply inverse QFT controlled unitaries [ q.cu1(-np.pi / 2**k, i, qubit) for qubit, k in enumerate(range(1, i + 1)[::-1]) if (i > 0) and (qubit < i) ] q.h(i) q.barrier() # Measure [q.measure(i, i) for i in range(bits)] if show: try: display(q.draw(output='mpl')) except: pass counts = execute(q, backend=backend, shots=shots).result().get_counts() ans = [int(c, 2) for c, v in counts.items() if v == max(counts.values())][0] # result with max counts estimated_theta = ans / (2**bits) if show: try: display(plot_histogram(counts)) print("Highest Count Value: ", bin(ans), " = ", ans) print(f"Estimated theta: {ans}/2^{bits} = ", estimated_theta) except: pass return estimated_theta, q
# # Executing it! # In[2]: # Compile the Scaffold to OpenQASM from scaffcc_interface import ScaffCC openqasmBell = ScaffCC(scaffold_codeBell).get_openqasm() print(openqasmBell) # ### Execute on a Simulator # In[3]: from qiskit import Aer, QuantumCircuit, execute Aer.backends() # In[4]: simulator = Aer.get_backend('qasm_simulator') vqe_circBell = QuantumCircuit.from_qasm_str(openqasmBell) num_shots = 100000 sim_resultBell = execute(vqe_circBell, simulator, shots=num_shots).result() countsBell = sim_resultBell.get_counts() expected_valueBellXX = (+countsBell.get('00', 0) - countsBell.get( '01', 0) + countsBell.get('10', 0) - countsBell.get('11', 0)) / num_shots expected_valueBellYY = (-countsBell.get('00', 0) + countsBell.get( '01', 0) + countsBell.get('10', 0) - countsBell.get('11', 0)) / num_shots expected_valueBellZZ = (+countsBell.get('00', 0) + countsBell.get(
inv_cnot.h(0) inv_cnot.h(1) inv_cnot.barrier() inv_cnot.measure(q, c) # In[51]: # Draw the circuit inv_cnot.draw(output='mpl') # In[52]: # Execute the circuit job = execute(inv_cnot, backend=Aer.get_backend('qasm_simulator'), shots=1024) result = job.result() # In[53]: # Print the result print(result.get_counts(inv_cnot)) # In[54]: # Plot the result from qiskit.visualization import plot_histogram plot_histogram(result.get_counts(inv_cnot))
def ChooseBackEnd(quantumCircuit, backendType="statevector_simulator", qubitsToBeMeasured=range(4), numberShots=4096, noisePresent=False, RealDeviceName="ibmq_ourense",number=12): if backendType == "statevector_simulator": backend = Aer.get_backend('statevector_simulator') result = execute(quantumCircuit, backend).result() probabilityVectors = np.square(np.absolute(result.get_statevector())) listForMusic = [] for k in range(2**len(qubitsToBeMeasured)): listForMusic.append("%.3f" % (probabilityVectors[k])) elif backendType == "qasm_simulator": if noisePresent == False: # no noise quantumCircuit.measure(qubitsToBeMeasured, qubitsToBeMeasured) print(qubitsToBeMeasured) backend = Aer.get_backend('qasm_simulator') result = execute(quantumCircuit, backend, shots=numberShots).result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") else: print(qubitsToBeMeasured) quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured) provider=IBMQ.save_account('XXX-YOUR-TOKEN') # simulate noise of a real device IBMQ.load_account() IBMQ.providers() device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName) properties = device.properties() coupling_map = device.configuration().coupling_map # Generate an Aer noise model for device noise_model = noise.device.basic_device_noise_model(properties) basis_gates = noise_model.basis_gates # Perform noisy simulation backend = Aer.get_backend('qasm_simulator') job_sim = execute(quantumCircuit, backend, coupling_map=coupling_map, noise_model=noise_model, basis_gates=basis_gates) result = job_sim.result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") elif backendType == "real_device": # real device quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured) provider=IBMQ.save_account('XXX-YOUR-TOKEN') # simulate noise of a real device IBMQ.load_account() IBMQ.providers() device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName) job_exp = execute(quantumCircuit, backend=device) job_monitor(job_exp) result = job_exp.result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append(" %.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") return listForMusic
half_adder1.cx(0,3) half_adder1.cx(1,3) half_adder1.ccx(0,1,4) half_adder1.barrier() half_adder1.ccx(3,2,5) #4 and 5 Or in 6 half_adder1.barrier() half_adder1.x(4) half_adder1.x(5) half_adder1.ccx(4,5,6) half_adder1.x(6) half_adder1.cx(2,3) half_adder1.barrier() half_adder1.measure(6,1) half_adder1.measure(3,0) counts = execute(half_adder1, Aer.get_backend("qasm_simulator")).result().get_counts() plot_histogram(counts) half_adder1.draw() """Above was a full-adder"""
# the LICENSE.txt file in the root directory of this source tree. """ Quantum teleportation example. Note: if you have only cloned the Qiskit repository but not used `pip install`, the examples only work from the root directory. """ from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit from qiskit import compile, Aer ############################################################### # Set the backend name and coupling map. ############################################################### coupling_map = [[0, 1], [0, 2], [1, 2], [3, 2], [3, 4], [4, 2]] backend = Aer.get_backend("qasm_simulator") ############################################################### # Make a quantum program for quantum teleportation. ############################################################### q = QuantumRegister(3, "q") c0 = ClassicalRegister(1, "c0") c1 = ClassicalRegister(1, "c1") c2 = ClassicalRegister(1, "c2") qc = QuantumCircuit(q, c0, c1, c2, name="teleport") # Prepare an initial state qc.u3(0.3, 0.2, 0.1, q[0]) # Prepare a Bell pair qc.h(q[1])
# specify the angles rotation_angle1 = random_angle/360*2*pi rotation_angle2 = rotation_angle1 + pi/2 # # first qubit # q1 = QuantumRegister(1) c1 = ClassicalRegister(1) qc1 = QuantumCircuit(q1,c1) # rotate the qubit qc1.ry(2 * rotation_angle1,q1[0]) # read the quantum state job = execute(qc1,Aer.get_backend('statevector_simulator'),optimization_level=0) current_quantum_state1=job.result().get_statevector(qc1) [x1,y1]=[current_quantum_state1[0].real,current_quantum_state1[1].real] # # second qubit # q2 = QuantumRegister(1) c2 = ClassicalRegister(1) qc2 = QuantumCircuit(q2,c2) # rotate the qubit qc2.ry(2 * rotation_angle2,q2[0]) # read the quantum state job = execute(qc2,Aer.get_backend('statevector_simulator'),optimization_level=0)
def sys_evolve_eng(nsites, excitations, total_time, dt, hop, U, trotter_steps): #Check for correct data types of input if not isinstance(nsites, int): raise TypeError("Number of sites should be int") if np.isscalar(excitations): raise TypeError("Initial state should be list or numpy array") if not np.isscalar(total_time): raise TypeError("Evolution time should be scalar") if not np.isscalar(dt): raise TypeError("Time step should be scalar") if not isinstance(trotter_steps, int): raise TypeError("Number of trotter slices should be int") numq = 2 * nsites num_steps = int(total_time / dt) print('Num Steps: ', num_steps) print('Total Time: ', total_time) data = np.zeros((2**numq, num_steps)) energies = np.zeros(num_steps) for t_step in range(0, num_steps): #Create circuit with t_step number of steps q = QuantumRegister(numq) c = ClassicalRegister(numq) qcirc = QuantumCircuit(q, c) #=========SET YOUR INITIAL STATE============== #Loop over each excitation for flip in excitations: qcirc.x(flip) # qcirc.h(flip) # qcirc.t(flip) #=============================================================== qcirc.barrier() #Append circuit with Trotter steps needed qc_evolve(qcirc, nsites, t_step * dt, dt, hop, U, trotter_steps) #Measure the circuit for i in range(numq): qcirc.measure(i, i) #Choose provider and backend #provider = IBMQ.get_provider() #backend = Aer.get_backend('statevector_simulator') backend = Aer.get_backend('qasm_simulator') #backend = provider.get_backend('ibmq_qasm_simulator') #backend = provider.get_backend('ibmqx4') #backend = provider.get_backend('ibmqx2') #backend = provider.get_backend('ibmq_16_melbourne') shots = 8192 max_credits = 10 #Max number of credits to spend on execution job_exp = execute(qcirc, backend=backend, shots=shots, max_credits=max_credits) #job_monitor(job_exp) result = job_exp.result() counts = result.get_counts(qcirc) #print(result.get_counts(qcirc)) print("Job: ", t_step + 1, " of ", num_steps, " computing energy...") #Store results in data array and normalize them for i in range(2**numq): if counts.get(get_bin(i, numq)) is None: dat = 0 else: dat = counts.get(get_bin(i, numq)) data[i, t_step] = dat / shots #======================================================= #Compute energy of system #Compute repulsion energies repulsion_energy = measure_repulsion(U, nsites, counts, shots) #Compute hopping energies #Get list of hopping pairs even_pairs = [] for i in range(0, nsites - 1, 2): #up_pair = [i, i+1] #dwn_pair = [i+nsites, i+nsites+1] even_pairs.append([i, i + 1]) even_pairs.append([i + nsites, i + nsites + 1]) odd_pairs = [] for i in range(1, nsites - 1, 2): odd_pairs.append([i, i + 1]) odd_pairs.append([i + nsites, i + nsites + 1]) #Start with even hoppings, initialize circuit and find hopping pairs q = QuantumRegister(numq) c = ClassicalRegister(numq) qcirc = QuantumCircuit(q, c) #Loop over each excitation for flip in excitations: qcirc.x(flip) qcirc.barrier() #Append circuit with Trotter steps needed qc_evolve(qcirc, nsites, t_step * dt, dt, hop, U, trotter_steps) even_hopping = measure_hopping(hop, even_pairs, qcirc, numq) #=============================================================== #Now do the same for the odd hoppings #Start with even hoppings, initialize circuit and find hopping pairs q = QuantumRegister(numq) c = ClassicalRegister(numq) qcirc = QuantumCircuit(q, c) #Loop over each excitation for flip in excitations: qcirc.x(flip) qcirc.barrier() #Append circuit with Trotter steps needed qc_evolve(qcirc, nsites, t_step * dt, dt, hop, U, trotter_steps) odd_hopping = measure_hopping(hop, odd_pairs, qcirc, numq) total_energy = repulsion_energy + even_hopping + odd_hopping energies[t_step] = total_energy print("Total Energy is: ", total_energy) print("Job: ", t_step + 1, " of ", num_steps, " complete") return data, energies
def test_aliases_return_empty_list(self): """Test backends() return an empty list if name is unknown.""" self.assertEqual(Aer.backends("bad_name"), [])
clbit_reg = ClassicalRegister(2, name='c') # Making first circuit: bell state qc1 = QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc1.h(qubit_reg[0]) qc1.cx(qubit_reg[0], qubit_reg[1]) qc1.measure(qubit_reg, clbit_reg) # Making another circuit: superpositions qc2 = QuantumCircuit(qubit_reg, clbit_reg, name="superposition") qc2.h(qubit_reg) qc2.measure(qubit_reg, clbit_reg) # Setting up the backend print("(Aer Backends)") for backend in Aer.backends(): print(backend.status()) my_backend = Aer.get_backend('local_qasm_simulator') print("(QASM Simulator configuration) ") pprint.pprint(my_backend.configuration()) print("(QASM Simulator properties) ") pprint.pprint(my_backend.properties()) print("\n(IMQ Backends)") for backend in IBMQ.backends(): print(backend.status()) # select least busy available device and execute. least_busy_device = least_busy(IBMQ.backends(simulator=False)) print("Running on current least busy device: ", least_busy_device)
def test_aer_deprecated(self): """test deprecated aer backends are resolved correctly""" old_name = 'local_qiskit_simulator' new_backend = Aer.get_backend(old_name) self.assertIsInstance(new_backend, QasmSimulator)
init_state = Custom(N_QUBITS, state_vector=init_state_vect) # Prepare the actual initial state with a quantum register qr = QuantumRegister(N_QUBITS) circuit_init = init_state.construct_circuit('circuit', qr) # Create as a partial so that when minimizing we don't change the values of the qr or of p. evaluate = partial(evaluate_circuit, qr=qr, p=p) # Minimize evaluate_circuit over gamma and beta only. # We are minimizing so that we can have the minimum cost Hamiltonian # This is the "variational" part of the algorithm. We are running the quantum circuit multiple times to find the minimum result = minimize(evaluate, np.concatenate([gamma, beta]), method='L-BFGS-B') print(result) # The above found the minimum beta and gamma. So we run the quantum circuit with these angles circuit = create_circuit(qr, result['x'][:p], result['x'][p:], p) backend = BasicAer.get_backend('statevector_simulator') job = execute(circuit, backend) state = np.asarray(job.result().get_statevector(circuit)) print(np.absolute(state)) print(np.angle(state)) Z0 = pauli_z(0, 1) Z1 = pauli_z(1, 1) print(Z0.eval("matrix", circuit, Aer.get_backend('statevector_simulator'))[0]) print(Z1.eval("matrix", circuit, Aer.get_backend('statevector_simulator'))[0])
def w_state_3q(): "Choice of the backend" # using local qasm simulator backend = Aer.get_backend('qasm_simulator') # using IBMQ qasm simulator # backend = IBMQ.get_backend('ibmq_qasm_simulator') # using real device # backend = least_busy(IBMQ.backends(simulator=False)) flag_qx2 = True if backend.name() == 'ibmqx4': flag_qx2 = False print("Your choice for the backend is: ", backend, "flag_qx2 is: ", flag_qx2) # 3-qubit W state n = 3 q = QuantumRegister(n) c = ClassicalRegister(n) W_states = QuantumCircuit(q, c) W_states.x(q[2]) # start is |100> F_gate(W_states, q, 2, 1, 3, 1) # Applying F12 F_gate(W_states, q, 1, 0, 3, 2) # Applying F23 if flag_qx2: # option ibmqx2 W_states.cx(q[1], q[2]) # cNOT 21 W_states.cx(q[0], q[1]) # cNOT 32 else: # option ibmqx4 cxrv(W_states, q, 1, 2) cxrv(W_states, q, 0, 1) for i in range(3): W_states.measure(q[i], c[i]) shots = 1000 time_exp = time.strftime('%d/%m/%Y %H:%M:%S') print('start W state 3-qubit on', backend, "N=", shots, time_exp) result = execute(W_states, backend=backend, shots=shots) time_exp = time.strftime('%d/%m/%Y %H:%M:%S') print('end W state 3-qubit on', backend, "N=", shots, time_exp) # In[39]: frequencies = result.result().get_counts(W_states) freq1 = frequencies['001'] freq2 = frequencies['010'] freq3 = frequencies['100'] line1 = [1] line2 = [2] line3 = [4] real_data = np.zeros( shape=1000) # real_data is actually an ndarray, not an array i = 0 linespassed = 0 for i in range(freq1): real_data[i] += line1 linespassed += freq1 for i in range(freq2): real_data[linespassed + i] += line2 linespassed += freq2 for i in range(freq3): real_data[linespassed + i] += line3 return real_data
noise_model.add_all_qubit_quantum_error(error_2, ["cx"]) # Get basis gates from noise model basis_gates = noise_model.basis_gates # Make a circuit circ = QuantumCircuit(3, 3) circ.h(0) circ.cx(0, 1) circ.cx(1, 2) circ.measure([0, 1, 2], [0, 1, 2]) # execute the quantum circuit result = execute( circ, Aer.get_backend("statevector_simulator"), basis_gates=basis_gates, noise_model=noise_model, ).result() psi = result.get_statevector(circ) counts = result.get_counts(0) circ.draw(output="mpl") plt.show() plot_state_city(psi) plot_state_hinton(psi) plot_state_qsphere(psi) plot_state_paulivec(psi) plot_bloch_multivector(psi)
def experiment(p, t, sigma_1, sigma_2, U, noise_model): #Note: p=1 is PEA + Scrambling gate (This is p=0 in other codes) n_register_qubits = p * t n_state_qubits = 2 n_or_qubits = p * (t - 1) register_qubits = QuantumRegister(n_register_qubits) state_qubits = QuantumRegister(n_state_qubits) or_qubits = QuantumRegister(n_or_qubits) c = ClassicalRegister(2) circ = QuantumCircuit(register_qubits, or_qubits, state_qubits, c) circ.h(state_qubits) #initial input state #Initial Round circ.h(register_qubits) #Controlled U(2) for i, q in enumerate(register_qubits[:t][::-1]): for k in range(0, 2**i): circ.unitary(Single_Controlled_Unitary(U), [state_qubits[1], state_qubits[0], q], label='cu') #QFT-dagger for qubit in range(int(t / 2)): circ.swap(qubit, t - qubit - 1) for j in range(t, 0, -1): k = t - j for m in range(k): circ.cu1(-np.pi / float(2**(k - m)), t - m - 1, t - k - 1) circ.h(t - k - 1) #Reset (OR + Scrambling gates) #OR-Gate circ.x(register_qubits[:t]) circ.x(or_qubits[0]) circ.ccx(register_qubits[0], register_qubits[1], or_qubits[0]) #Scrambling gate circ.ch(or_qubits[0], state_qubits) #Subsequent Rounds for j in range(1, p): #CCU for i, q in enumerate(register_qubits[t * j:t * (j + 1)][::-1]): for k in range(0, 2**i): circ.unitary( Two_Controlled_Unitary(U), [state_qubits[1], state_qubits[0], or_qubits[j - 1], q], label='ccu') #QFT-dagger for qubit in range(int(t / 2)): circ.swap(qubit + t * j, t - qubit - 1 + t * j) for f in range(t, 0, -1): k = t - f for m in range(k): circ.cu1(-np.pi / float(2**(k - m)), t - m - 1 + t * j, t - k - 1 + t * j) circ.h(t - k - 1 + t * j) #OR-Gate circ.x(register_qubits[t * j:t * (j + 1)]) circ.x(or_qubits[j]) circ.ccx(register_qubits[t * j], register_qubits[t * j + 1], or_qubits[j]) #Scrambling gate circ.ch(or_qubits[j], state_qubits) #Pauli Measurements (There's a neater way to do this!) if sigma_1 == 'z' and sigma_2 == 'I': circ.iden(state_qubits[0]) circ.iden(state_qubits[1]) if sigma_1 == 'x' and sigma_2 == 'I': circ.h(state_qubits[0]) circ.iden(state_qubits[1]) if sigma_1 == 'y' and sigma_2 == 'I': circ.sdg(state_qubits[0]) circ.h(state_qubits[0]) circ.iden(state_qubits[1]) if sigma_1 == 'I' and sigma_2 == 'z': circ.swap(state_qubits[0], state_qubits[1]) if sigma_1 == 'I' and sigma_2 == 'x': circ.swap(state_qubits[0], state_qubits[1]) circ.h(state_qubits[0]) circ.iden(state_qubits[1]) if sigma_1 == 'I' and sigma_2 == 'y': circ.swap(state_qubits[0], state_qubits[1]) circ.iden(state_qubits[1]) circ.sdg(state_qubits[0]) circ.h(state_qubits[0]) if sigma_1 == 'z' and sigma_2 == 'z': circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'z' and sigma_2 == 'x': circ.h(state_qubits[1]) circ.iden(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'z' and sigma_2 == 'y': circ.sdg(state_qubits[1]) circ.h(state_qubits[1]) circ.iden(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'x' and sigma_2 == 'z': circ.iden(state_qubits[1]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'x' and sigma_2 == 'x': circ.h(state_qubits[1]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'x' and sigma_2 == 'y': circ.sdg(state_qubits[1]) circ.h(state_qubits[1]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'y' and sigma_2 == 'z': circ.iden(state_qubits[1]) circ.sdg(state_qubits[0]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'y' and sigma_2 == 'x': circ.h(state_qubits[1]) circ.sdg(state_qubits[0]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) if sigma_1 == 'y' and sigma_2 == 'y': circ.sdg(state_qubits[1]) circ.h(state_qubits[1]) circ.sdg(state_qubits[0]) circ.h(state_qubits[0]) circ.cx(state_qubits[1], state_qubits[0]) circ.measure(state_qubits, c) shots = 8192 #IBMQ.load_account() #provider = IBMQ.get_provider('ibm-q') #qcomp = provider.get_backend('ibmq_qasm_simulator') qcomp = Aer.get_backend('qasm_simulator') job = execute(circ, backend=qcomp, shots=shots, noise_model=noise_model, basis_gates=noise_model.basis_gates) #print(job_monitor(job)) result = job.result() result_dictionary = result.get_counts(circ) probs = {} for output in ['00', '01', '10', '11']: if output in result_dictionary: probs[output] = result_dictionary[output] else: probs[output] = 0 return (probs['00'] + probs['11'] - probs['01'] - probs['10']) / shots