def recive(self): c = ClassicalRegister(n) self.channel.
def build_circuit(n: int, f: Callable[[str], str]) -> QuantumCircuit: # implement the Bernstein-Vazirani circuit zero = np.binary_repr(0, n) b = f(zero) # initial n + 1 bits input_qubit = QuantumRegister(n + 1, "qc") classicals = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classicals) # inverse last one (can be omitted if using O_f^\pm) prog.x(input_qubit[n]) # circuit begin prog.h(input_qubit[1]) # number=1 prog.h(input_qubit[2]) # number=38 prog.cz(input_qubit[0], input_qubit[2]) # number=39 prog.h(input_qubit[2]) # number=40 prog.cx(input_qubit[0], input_qubit[2]) # number=31 prog.h(input_qubit[2]) # number=42 prog.cz(input_qubit[0], input_qubit[2]) # number=43 prog.h(input_qubit[2]) # number=44 prog.h(input_qubit[2]) # number=48 prog.cz(input_qubit[0], input_qubit[2]) # number=49 prog.h(input_qubit[2]) # number=50 prog.cx(input_qubit[0], input_qubit[2]) # number=54 prog.x(input_qubit[2]) # number=55 prog.cx(input_qubit[0], input_qubit[2]) # number=56 prog.cx(input_qubit[0], input_qubit[2]) # number=47 prog.cx(input_qubit[0], input_qubit[2]) # number=37 prog.h(input_qubit[2]) # number=51 prog.cz(input_qubit[0], input_qubit[2]) # number=52 prog.h(input_qubit[2]) # number=53 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0], input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.h(input_qubit[1]) # number=7 prog.cz(input_qubit[2], input_qubit[1]) # number=8 prog.rx(0.17592918860102857, input_qubit[2]) # number=34 prog.rx(-0.3989822670059037, input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=9 prog.h(input_qubit[1]) # number=18 prog.cz(input_qubit[2], input_qubit[1]) # number=19 prog.h(input_qubit[1]) # number=20 prog.y(input_qubit[1]) # number=14 prog.h(input_qubit[1]) # number=22 prog.cz(input_qubit[2], input_qubit[1]) # number=23 prog.rx(-0.9173450548482197, input_qubit[1]) # number=57 prog.h(input_qubit[1]) # number=24 prog.z(input_qubit[2]) # number=3 prog.z(input_qubit[1]) # number=41 prog.x(input_qubit[1]) # number=17 prog.y(input_qubit[2]) # number=5 prog.x(input_qubit[2]) # number=21 # apply H to get superposition for i in range(n): prog.h(input_qubit[i]) prog.h(input_qubit[n]) prog.barrier() # apply oracle O_f oracle = build_oracle(n, f) prog.append(oracle.to_gate(), [input_qubit[i] for i in range(n)] + [input_qubit[n]]) # apply H back (QFT on Z_2^n) for i in range(n): prog.h(input_qubit[i]) prog.barrier() # measure return prog
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.rx(-1.3603096190043806, input_qubit[2]) # number=28 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[3]) # number=34 prog.cz(input_qubit[4], input_qubit[3]) # number=35 prog.h(input_qubit[3]) # number=36 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1], input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.cx(input_qubit[1], input_qubit[0]) # number=56 prog.x(input_qubit[0]) # number=57 prog.cx(input_qubit[1], input_qubit[0]) # number=58 prog.cx(input_qubit[1], input_qubit[0]) # number=33 prog.cx(input_qubit[0], input_qubit[1]) # number=24 prog.x(input_qubit[1]) # number=25 prog.x(input_qubit[1]) # number=41 prog.h(input_qubit[1]) # number=50 prog.cz(input_qubit[0], input_qubit[1]) # number=51 prog.h(input_qubit[1]) # number=52 prog.x(input_qubit[2]) # number=11 prog.cx(input_qubit[2], input_qubit[3]) # number=30 prog.x(input_qubit[3]) # number=12 prog.h(input_qubit[2]) # number=42 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[4]) # number=46 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=53 prog.cz(input_qubit[0], input_qubit[2]) # number=54 prog.h(input_qubit[2]) # number=55 prog.x(input_qubit[2]) # number=44 prog.h(input_qubit[2]) # number=47 prog.cz(input_qubit[0], input_qubit[2]) # number=48 prog.h(input_qubit[2]) # number=49 prog.rx(-1.9697785938008003, input_qubit[1]) # number=37 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.x(input_qubit[1]) # number=22 prog.x(input_qubit[1]) # number=23 # circuit end return prog
def _build_simple_circuit(_): qreg = QuantumRegister(2) creg = ClassicalRegister(2) qc = QuantumCircuit(qreg, creg) return qc
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(1): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=33 prog.cz(input_qubit[1], input_qubit[0]) # number=34 prog.h(input_qubit[0]) # number=35 prog.rx(-0.7822565707438585, input_qubit[2]) # number=31 prog.x(input_qubit[0]) # number=29 prog.h(input_qubit[0]) # number=40 prog.cz(input_qubit[1], input_qubit[0]) # number=41 prog.h(input_qubit[0]) # number=42 prog.cx(input_qubit[0], input_qubit[1]) # number=25 prog.x(input_qubit[1]) # number=26 prog.cx(input_qubit[0], input_qubit[1]) # number=27 prog.cx(input_qubit[0], input_qubit[2]) # number=22 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0], input_qubit[2]) # number=24 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[3]) # number=37 prog.cz(input_qubit[2], input_qubit[3]) # number=38 prog.h(input_qubit[3]) # number=39 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.rx(2.5761059759436304, input_qubit[3]) # number=32 prog.h(input_qubit[3]) # number=20 prog.h(input_qubit[0]) prog.h(input_qubit[1]) prog.h(input_qubit[2]) prog.h(input_qubit[3]) # circuit end return prog
def QFT(): # Import the QISKit SDK from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister from qiskit import execute # Create a Quantum Register with 5 qubits Q = QuantumRegister(5) # Create a Classical Register with 5 bits C = ClassicalRegister(5) # Create a Quantum Circuit QC = QuantumCircuit(Q, C) # Add the necessary gates QC.u2(0.0, 3.2397674240144743, Q[4]) QC.u1(0.196349540849362, Q[3]) QC.u2(0.0, 3.5342917352885173, Q[2]) QC.u2(0.0, 3.9269908169872414, Q[1]) QC.u1(6.283185307179586, Q[0]) QC.cx(Q[0], Q[1]) QC.u1(6.283185307179586, Q[1]) QC.u3(0.7853981633974485, 1.5707963267948966, 4.71238898038469, Q[0]) QC.cx(Q[0], Q[1]) QC.u1(6.283185307179586, Q[1]) QC.u3(-0.7853981633974485, 1.5707963267948966, 4.71238898038469, Q[0]) QC.cx(Q[0], Q[2]) QC.u1(6.283185307179586, Q[2]) QC.u3(0.392699081698724, 1.5707963267948966, 4.71238898038469, Q[0]) QC.cx(Q[0], Q[2]) QC.u2(0.7853981633974485, 3.141592653589793, Q[2]) QC.u2(0.392699081698724, 3.141592653589793, Q[0]) QC.cx(Q[0], Q[2]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[0], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.cx(Q[0], Q[2]) QC.cx(Q[0], Q[1]) QC.u1(-0.7853981633974485, Q[1]) QC.cx(Q[0], Q[1]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.u1(0.7853981633974485, Q[1]) QC.cx(Q[0], Q[1]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.u2(0.0, 3.141592653589793, Q[1]) QC.cx(Q[0], Q[1]) QC.u2(0.0, 3.141592653589793, Q[1]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.cx(Q[0], Q[1]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.cx(Q[3], Q[2]) QC.u1(-0.196349540849362, Q[2]) QC.cx(Q[3], Q[2]) QC.u1(0.392699081698724, Q[3]) QC.u1(0.196349540849362, Q[2]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[0], Q[2]) QC.u1(6.283185307179586, Q[2]) QC.u3(0.392699081698724, 1.5707963267948966, 4.71238898038469, Q[0]) QC.cx(Q[0], Q[2]) QC.u2(0.7853981633974485, 3.141592653589793, Q[2]) QC.u2(0.392699081698724, 3.141592653589793, Q[0]) QC.cx(Q[0], Q[2]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[0], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.u2(0.0, 3.141592653589793, Q[0]) QC.cx(Q[0], Q[2]) QC.cx(Q[0], Q[1]) QC.u1(-0.7853981633974485, Q[1]) QC.cx(Q[0], Q[1]) QC.u1(6.283185307179586, Q[0]) QC.u2(0.0, 3.9269908169872414, Q[1]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.cx(Q[3], Q[4]) QC.u1(6.283185307179586, Q[4]) QC.u3(0.098174770424681, 1.5707963267948966, 4.71238898038469, Q[3]) QC.cx(Q[3], Q[4]) QC.u2(0.196349540849362, 3.141592653589793, Q[4]) QC.u2(0.098174770424681, 3.141592653589793, Q[3]) QC.cx(Q[3], Q[4]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.u2(0.0, 3.141592653589793, Q[4]) QC.cx(Q[3], Q[4]) QC.u2(0.0, 3.141592653589793, Q[4]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.cx(Q[3], Q[4]) QC.cx(Q[3], Q[2]) QC.u1(-0.196349540849362, Q[2]) QC.cx(Q[3], Q[2]) QC.u1(0.392699081698724, Q[3]) QC.u1(0.196349540849362, Q[2]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.u2(0.0, 3.141592653589793, Q[3]) QC.cx(Q[3], Q[2]) QC.u2(0.0, 3.141592653589793, Q[2]) QC.cx(Q[1], Q[2]) QC.u1(6.283185307179586, Q[2]) QC.u3(0.392699081698724, 1.5707963267948966, 4.71238898038469, Q[1]) QC.cx(Q[1], Q[2]) QC.u3(-0.7853981633974485, 1.5707963267948966, 4.71238898038469, Q[2]) QC.cx(Q[0], Q[2]) QC.u1(6.283185307179586, Q[2]) QC.u3(0.7853981633974485, 1.5707963267948966, 4.71238898038469, Q[0]) QC.cx(Q[0], Q[2]) QC.u1(6.283185307179586, Q[2]) QC.u2(0.7853981633974485, 3.141592653589793, Q[0]) QC.u2(0.392699081698724, 3.141592653589793, Q[1]) # Add the Measure gates QC.measure(Q, C) # Compile and run the Quantum circuit on a simulator backend Sim_Job = execute(QC, "local_qasm_simulator") # Get the result and period #import json Sim_Job_Result = Sim_Job.result() Sim_Job_Counts = Sim_Job_Result.get_counts(QC) Period = 0 Value_Data = -1 for Key, Value in Sim_Job_Counts.items(): Key_Data = int(Key, 2) if (Value_Data < Value): Period = Key_Data Value_Data = Value return Period
def setUp(self): self.qr = QuantumRegister(3, "q") self.qr2 = QuantumRegister(3, "r") self.cr = ClassicalRegister(3, "c") self.circuit = QuantumCircuit(self.qr, self.qr2, self.cr) self.c_header = 69 # lenght of the header
# written by David Byrne, based on circuits in N. David Mermin's "Quantum Computer Science: An Introduction" import numpy as np import random from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer from qiskit.tools.visualization import plot_bloch_vector unkownNumber = random.randint(0,31) q = QuantumRegister(6) output = ClassicalRegister(6) circuit = QuantumCircuit(q, output) # set the circuit up in the correct state circuit.x(q[5]) for i in range(0, 6): circuit.h(q[i]) # apply the oracle (which, at this point makes the algorithm pointless because it's limited by the classical process of applying the gates) for i in range(0, 5): if (2 ** i) & unkownNumber: circuit.cx(q[i], q[5]) # reduce the phase for i in range(0, 6): circuit.h(q[i]) # measure the value of a circuit.measure(q, output) # evaluate the value of the unkownNumber backend = BasicAer.get_backend('statevector_simulator')
def _run(self): # construct circuit self.construct_circuit() if self._quantum_instance.is_statevector: # run circuit on statevector simlator ret = self._quantum_instance.execute(self._circuit) state_vector = np.asarray([ret.get_statevector(self._circuit)]) self._ret['statevector'] = state_vector # get state probabilities state_probabilities = np.real(state_vector.conj() * state_vector)[0] # evaluate results a_probabilities, y_probabilities = self._evaluate_statevector_results(state_probabilities) else: # run circuit on QASM simulator qc = self._circuit cr = ClassicalRegister(self._m) qc.add_register(cr) qc.measure([q for q in qc.qregs if q.name == 'a'][0], cr) ret = self._quantum_instance.execute(self._circuit) # get counts self._ret['counts'] = ret.get_counts() # construct probabilities y_probabilities = {} a_probabilities = {} shots = sum(ret.get_counts().values()) for state, counts in ret.get_counts().items(): y = int(state.replace(' ', '')[:self._m][::-1], 2) p = counts / shots y_probabilities[y] = p a = np.power(np.sin(y * np.pi / 2 ** self._m), 2) a_probabilities[a] = a_probabilities.get(a, 0.0) + p # construct a_items and y_items a_items = [(a, p) for (a, p) in a_probabilities.items() if p > 1e-6] y_items = [(y, p) for (y, p) in y_probabilities.items() if p > 1e-6] a_items = sorted(a_items) y_items = sorted(y_items) self._ret['a_items'] = a_items self._ret['y_items'] = y_items # map estimated values to original range and extract probabilities self._ret['mapped_values'] = [self.a_factory.value_to_estimation(a_item[0]) for a_item in self._ret['a_items']] self._ret['values'] = [a_item[0] for a_item in self._ret['a_items']] self._ret['y_values'] = [y_item[0] for y_item in y_items] self._ret['probabilities'] = [a_item[1] for a_item in self._ret['a_items']] self._ret['mapped_items'] = [(self._ret['mapped_values'][i], self._ret['probabilities'][i]) for i in range(len(self._ret['mapped_values']))] # determine most likely estimator self._ret['estimation'] = None self._ret['max_probability'] = 0 for val, prob in self._ret['mapped_items']: if prob > self._ret['max_probability']: self._ret['max_probability'] = prob self._ret['estimation'] = val return self._ret
def __init__(self, backend=Aer.get_backend('qasm_simulator'), shots=1024, mode='circle', y_boxes=False): """ backend=Aer.get_backend('qasm_simulator') Backend to be used by Qiskit to calculate expectation values (defaults to local simulator). shots=1024 Number of shots used to to calculate expectation values. mode='circle' Either the standard 'Hello Quantum' visualization can be used (with mode='circle') or the alternative line based one (mode='line'). y_boxes=True Whether to display full grid that includes Y expectation values. """ self.backend = backend self.shots = shots self.y_boxes = y_boxes if self.y_boxes: self.box = { 'ZI': (-1, 2), 'XI': (-3, 4), 'IZ': (1, 2), 'IX': (3, 4), 'ZZ': (0, 3), 'ZX': (2, 5), 'XZ': (-2, 5), 'XX': (0, 7), 'YY': (0, 5), 'YI': (-2, 3), 'IY': (2, 3), 'YZ': (-1, 4), 'ZY': (1, 4), 'YX': (1, 6), 'XY': (-1, 6) } else: self.box = { 'ZI': (-1, 2), 'XI': (-2, 3), 'IZ': (1, 2), 'IX': (2, 3), 'ZZ': (0, 3), 'ZX': (1, 4), 'XZ': (-1, 4), 'XX': (0, 5) } self.rho = {} for pauli in self.box: self.rho[pauli] = 0.0 for pauli in ['ZI', 'IZ', 'ZZ']: self.rho[pauli] = 1.0 self.qr = QuantumRegister(2) self.cr = ClassicalRegister(2) self.qc = QuantumCircuit(self.qr, self.cr) self.mode = mode # colors are background, qubit circles and correlation circles, respectively if self.mode == 'line': self.colors = [(1.6 / 255, 72 / 255, 138 / 255), (132 / 255, 177 / 255, 236 / 255), (33 / 255, 114 / 255, 216 / 255)] else: self.colors = [(1.6 / 255, 72 / 255, 138 / 255), (132 / 255, 177 / 255, 236 / 255), (33 / 255, 114 / 255, 216 / 255)] if self.mode != 'y': figsize = (5, 5) else: figsize = (6, 6) self.fig = plt.figure(figsize=(6, 6), facecolor=self.colors[0]) self.ax = self.fig.add_subplot(111) plt.axis('off') self.bottom = self.ax.text(-3, 1, "", size=9, va='top', color='w') self.points = {} for pauli in self.box: self.points[pauli] = [ self.ax.add_patch( Circle(self.box[pauli], 0.0, color=(0, 0, 0), zorder=10)) ] self.points[pauli].append( self.ax.add_patch( Circle(self.box[pauli], 0.0, color=(1, 1, 1), zorder=10)))
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.cx(input_qubit[0], input_qubit[2]) # number=35 prog.x(input_qubit[2]) # number=36 prog.cx(input_qubit[0], input_qubit[2]) # number=37 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(1): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.y(input_qubit[1]) # number=31 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1], input_qubit[0]) # number=28 prog.x(input_qubit[0]) # number=29 prog.cx(input_qubit[1], input_qubit[0]) # number=30 prog.x(input_qubit[1]) # number=10 prog.cx(input_qubit[0], input_qubit[2]) # number=22 prog.cx(input_qubit[0], input_qubit[2]) # number=25 prog.x(input_qubit[2]) # number=26 prog.cx(input_qubit[0], input_qubit[2]) # number=27 prog.cx(input_qubit[0], input_qubit[2]) # number=24 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.rx(1.7404423300887455, input_qubit[1]) # number=32 prog.z(input_qubit[1]) # number=33 prog.h(input_qubit[3]) # number=20 prog.h(input_qubit[0]) prog.h(input_qubit[1]) prog.h(input_qubit[2]) prog.h(input_qubit[3]) # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit from qiskit import BasicAer from qiskit import execute ############################################################### # Set the backend name and coupling map. ############################################################### coupling_map = [[0, 1], [0, 2], [1, 2], [3, 2], [3, 4], [4, 2]] backend = BasicAer.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]) qc.cx(q[1], q[2]) # Barrier following state preparation qc.barrier(q) # Measure in the Bell basis
circuit.t(q[1]) circuit.cx(q[0], q[1]) circuit.t(q[0]) circuit.tdg(q[1]) # n-qubit number input state def number_state(circuit, q, a, b): if a == 1: circuit.x(q[0]) # q[0] contains the value of a if b == 1: circuit.x(q[1]) # q[1] contain the value of b qr = QuantumRegister(3) cr = ClassicalRegister(3) qc = QuantumCircuit(qr, cr) a = 0 b = 0 if (sys.argv[1] == '1'): a = 1 if (sys.argv[2] == '1'): b = 1 number_state(qc, qr, a, b) addition_1bit(qc, qr) qc.measure(qr, cr) circuit_drawer(qc, filename="imgs/f_add_1bit.png")
def test_mapping_correction(self): """Test mapping works in previous failed case. """ backend = FakeRueschlikon() qr = QuantumRegister(name='qr', size=11) cr = ClassicalRegister(name='qc', size=11) circuit = QuantumCircuit(qr, cr) circuit.u3(1.564784764685993, -1.2378965763410095, 2.9746763177861713, qr[3]) circuit.u3(1.2269835563676523, 1.1932982847014162, -1.5597357740824318, qr[5]) circuit.cx(qr[5], qr[3]) circuit.u1(0.856768317675967, qr[3]) circuit.u3(-3.3911273825190915, 0.0, 0.0, qr[5]) circuit.cx(qr[3], qr[5]) circuit.u3(2.159209321625547, 0.0, 0.0, qr[5]) circuit.cx(qr[5], qr[3]) circuit.u3(0.30949966910232335, 1.1706201763833217, 1.738408691990081, qr[3]) circuit.u3(1.9630571407274755, -0.6818742967975088, 1.8336534616728195, qr[5]) circuit.u3(1.330181833806101, 0.6003162754946363, -3.181264980452862, qr[7]) circuit.u3(0.4885914820775024, 3.133297443244865, -2.794457469189904, qr[8]) circuit.cx(qr[8], qr[7]) circuit.u1(2.2196187596178616, qr[7]) circuit.u3(-3.152367609631023, 0.0, 0.0, qr[8]) circuit.cx(qr[7], qr[8]) circuit.u3(1.2646005789809263, 0.0, 0.0, qr[8]) circuit.cx(qr[8], qr[7]) circuit.u3(0.7517780502091939, 1.2828514296564781, 1.6781179605443775, qr[7]) circuit.u3(0.9267400575390405, 2.0526277839695153, 2.034202361069533, qr[8]) circuit.u3(2.550304293455634, 3.8250017126569698, -2.1351609599720054, qr[1]) circuit.u3(0.9566260876600556, -1.1147561503064538, 2.0571590492298797, qr[4]) circuit.cx(qr[4], qr[1]) circuit.u1(2.1899329069137394, qr[1]) circuit.u3(-1.8371715243173294, 0.0, 0.0, qr[4]) circuit.cx(qr[1], qr[4]) circuit.u3(0.4717053496327104, 0.0, 0.0, qr[4]) circuit.cx(qr[4], qr[1]) circuit.u3(2.3167620677708145, -1.2337330260253256, -0.5671322899563955, qr[1]) circuit.u3(1.0468499525240678, 0.8680750644809365, -1.4083720073192485, qr[4]) circuit.u3(2.4204244021892807, -2.211701932616922, 3.8297006565735883, qr[10]) circuit.u3(0.36660280497727255, 3.273119149343493, -1.8003362351299388, qr[6]) circuit.cx(qr[6], qr[10]) circuit.u1(1.067395863586385, qr[10]) circuit.u3(-0.7044917541291232, 0.0, 0.0, qr[6]) circuit.cx(qr[10], qr[6]) circuit.u3(2.1830003849921527, 0.0, 0.0, qr[6]) circuit.cx(qr[6], qr[10]) circuit.u3(2.1538343756723917, 2.2653381826084606, -3.550087952059485, qr[10]) circuit.u3(1.307627685019188, -0.44686656993522567, -2.3238098554327418, qr[6]) circuit.u3(2.2046797998462906, 0.9732961754855436, 1.8527865921467421, qr[9]) circuit.u3(2.1665254613904126, -1.281337664694577, -1.2424905413631209, qr[0]) circuit.cx(qr[0], qr[9]) circuit.u1(2.6209599970201007, qr[9]) circuit.u3(0.04680566321901303, 0.0, 0.0, qr[0]) circuit.cx(qr[9], qr[0]) circuit.u3(1.7728411151289603, 0.0, 0.0, qr[0]) circuit.cx(qr[0], qr[9]) circuit.u3(2.4866395967434443, 0.48684511243566697, -3.0069186877854728, qr[9]) circuit.u3(1.7369112924273789, -4.239660866163805, 1.0623389015296005, qr[0]) circuit.barrier(qr) circuit.measure(qr, cr) circuits = transpile(circuit, backend) self.assertIsInstance(circuits, QuantumCircuit)
def cu3_gate_circuits_deterministic(final_measure): circuits = [] qr = QuantumRegister(2) if final_measure: cr = ClassicalRegister(2) regs = (qr, cr) else: regs = (qr, ) # I^X.CI.I^X circuit = QuantumCircuit(*regs) circuit.x(qr[0]) circuit.cu3(0, 0, 0, qr[0], qr[1]) circuit.x(qr[0]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CX circuit = QuantumCircuit(*regs) circuit.cu3(np.pi, 0, np.pi, qr[0], qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # I^X.CX.I^X circuit = QuantumCircuit(*regs) circuit.x(qr[0]) circuit.cu3(np.pi, 0, np.pi, qr[0], qr[1]) circuit.x(qr[0]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^X.CH.I^X circuit = QuantumCircuit(*regs) circuit.x(qr[0]) circuit.cu3(np.pi / 2, 0, np.pi, qr[0], qr[1]) circuit.x(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # I^X.CRX(pi).I^X circuit = QuantumCircuit(*regs) circuit.x(qr[0]) circuit.cu3(np.pi, -np.pi / 2, np.pi / 2, qr[0], qr[1]) circuit.x(qr[0]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # I^X.CRY(pi).I^X circuit = QuantumCircuit(*regs) circuit.x(qr[0]) circuit.cu3(np.pi, 0, 0, qr[0], qr[1]) circuit.x(qr[0]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) return circuits
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[4],input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.h(input_qubit[0]) # number=56 prog.cz(input_qubit[4],input_qubit[0]) # number=57 prog.h(input_qubit[0]) # number=58 prog.cx(input_qubit[4],input_qubit[0]) # number=59 prog.z(input_qubit[4]) # number=60 prog.cx(input_qubit[4],input_qubit[0]) # number=61 prog.cx(input_qubit[4],input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=37 prog.cz(input_qubit[4],input_qubit[0]) # number=38 prog.h(input_qubit[0]) # number=39 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(-1.0430087609918113,input_qubit[4]) # number=36 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1],input_qubit[0]) # number=40 prog.cx(input_qubit[1],input_qubit[0]) # number=52 prog.x(input_qubit[0]) # number=53 prog.cx(input_qubit[1],input_qubit[0]) # number=54 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1],input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.x(input_qubit[1]) # number=10 prog.rx(-0.06597344572538572,input_qubit[3]) # number=27 prog.cx(input_qubit[0],input_qubit[2]) # number=22 prog.x(input_qubit[2]) # number=23 prog.h(input_qubit[2]) # number=28 prog.cz(input_qubit[0],input_qubit[2]) # number=29 prog.h(input_qubit[2]) # number=30 prog.x(input_qubit[3]) # number=12 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[4]) # number=35 prog.h(input_qubit[0]) # number=17 prog.rx(2.4912829742967055,input_qubit[2]) # number=26 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[2]) # number=55 prog.h(input_qubit[2]) # number=25 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def cswap_gate_circuits_nondeterministic(final_measure=True): """cswap-gate test circuits with deterministic counts.""" circuits = [] qr = QuantumRegister(3) if final_measure: cr = ClassicalRegister(3) regs = (qr, cr) else: regs = (qr, ) # CSWAP(0,1,2).(H^H^H) circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.h(qr[1]) circuit.h(qr[2]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(X^I^H). -> |100> + |011> circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.x(qr[2]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(I^X^H). -> |010> + |101> circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.x(qr[1]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(I^H^I) -> |010>+|000> circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(H^I^I) -> |100>+|000> circuit = QuantumCircuit(*regs) circuit.h(qr[2]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(I^I^H) -> |001>+|000> circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # CSWAP(0,1,2).(X^X^H) -> |110> + |111> circuit = QuantumCircuit(*regs) circuit.h(qr[0]) circuit.x(qr[1]) circuit.x(qr[2]) circuit.cswap(qr[0], qr[1], qr[2]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) return circuits
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[4], input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.z(input_qubit[4]) # number=55 prog.cx(input_qubit[4], input_qubit[0]) # number=56 prog.h(input_qubit[2]) # number=50 prog.cz(input_qubit[4], input_qubit[2]) # number=51 prog.h(input_qubit[2]) # number=52 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=28 prog.cx(input_qubit[3], input_qubit[0]) # number=60 prog.z(input_qubit[3]) # number=61 prog.cx(input_qubit[3], input_qubit[0]) # number=62 prog.cz(input_qubit[1], input_qubit[0]) # number=29 prog.h(input_qubit[0]) # number=30 prog.h(input_qubit[0]) # number=43 prog.cz(input_qubit[1], input_qubit[0]) # number=44 prog.h(input_qubit[0]) # number=45 prog.cx(input_qubit[1], input_qubit[0]) # number=35 prog.cx(input_qubit[1], input_qubit[0]) # number=38 prog.x(input_qubit[0]) # number=39 prog.cx(input_qubit[1], input_qubit[0]) # number=40 prog.cx(input_qubit[1], input_qubit[0]) # number=37 prog.h(input_qubit[0]) # number=46 prog.cz(input_qubit[1], input_qubit[0]) # number=47 prog.h(input_qubit[0]) # number=48 prog.h(input_qubit[0]) # number=63 prog.cz(input_qubit[1], input_qubit[0]) # number=64 prog.h(input_qubit[0]) # number=65 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.x(input_qubit[3]) # number=12 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.cx(input_qubit[0], input_qubit[1]) # number=22 prog.y(input_qubit[2]) # number=41 prog.x(input_qubit[1]) # number=23 prog.cx(input_qubit[0], input_qubit[1]) # number=24 prog.rx(1.0398671683382215, input_qubit[2]) # number=31 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end return prog
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[0]) # number=44 prog.cz(input_qubit[3], input_qubit[0]) # number=45 prog.h(input_qubit[0]) # number=46 prog.z(input_qubit[3]) # number=33 prog.h(input_qubit[0]) # number=48 prog.cz(input_qubit[3], input_qubit[0]) # number=49 prog.h(input_qubit[0]) # number=50 prog.rx(0.11938052083641225, input_qubit[1]) # number=36 prog.cx(input_qubit[1], input_qubit[2]) # number=47 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.rx(1.4765485471872026, input_qubit[2]) # number=35 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1], input_qubit[0]) # number=41 prog.x(input_qubit[0]) # number=42 prog.cx(input_qubit[1], input_qubit[0]) # number=43 prog.x(input_qubit[4]) # number=30 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.rx(0.45238934211692994, input_qubit[3]) # number=38 prog.y(input_qubit[1]) # number=39 prog.rx(-2.5258404934861938, input_qubit[1]) # number=25 prog.h(input_qubit[3]) # number=29 prog.cx(input_qubit[0], input_qubit[3]) # number=22 prog.x(input_qubit[3]) # number=23 prog.cx(input_qubit[0], input_qubit[3]) # number=24 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.rx(-0.0722566310325653, input_qubit[4]) # number=37 prog.x(input_qubit[1]) # number=14 prog.cx(input_qubit[0], input_qubit[2]) # number=26 prog.x(input_qubit[2]) # number=27 prog.h(input_qubit[4]) # number=40 prog.cx(input_qubit[0], input_qubit[2]) # number=28 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
as possible. Classically, it requires 2^{n-1}+1 function evaluations in the worst case. Using the Deutsch-Jozsa algorithm, the question can be answered with just one function evaluation. Deutsch's algorithm is the simpler case of Deutsch-Jozsa Algorithm which has a function f(x) which takes 1-bit as input. Source: https://github.com/Qiskit/ibmqx-user-guides/blob/master/rst/full-user-guide/004-Quantum_Algorithms/080-Deutsch-Jozsa_Algorithm.rst ''' from qiskit import IBMQ, BasicAer from qiskit.providers.ibmq import least_busy from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute from qiskit.tools.monitor import job_monitor qr = QuantumRegister(2) # Initialize two qubits cr = ClassicalRegister(2) # Initialize two bits for record measurements circuit = QuantumCircuit(qr, cr) circuit.x(qr[1]) # initialize the ancilla qubit in the |1> state circuit.barrier() # First step of quantum algorithms - Prepare the superposition # For superposition, we apply the Hadamard gate on both qubits circuit.h(qr[0]) circuit.h(qr[1]) circuit.barrier() # Oracle function circuit.cx(qr[0], qr[1])
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon May 20 21:07:00 2019 @author: hnorlen """ from qiskit import QuantumRegister, ClassicalRegister from qiskit import QuantumCircuit, Aer, execute q = QuantumRegister(1) c = ClassicalRegister(1) qc = QuantumCircuit(q, c) qc.h(q[0]) qc.measure(q, c) print(qc) backend = Aer.get_backend('qasm_simulator') job = execute(qc, backend, shots=1) result = job.result() counts = result.get_counts(qc) print(counts) from qiskit.tools.visualization import plot_histogram plot_histogram(counts) from qiskit.tools.visualization import plot_bloch_vector
def add_circuits(self, n_circuits, do_measure=True, basis=None, basis_weights=None): """Adds circuits to program. Generates a circuit with a random number of operations in `basis`. Also adds a random number of measurements in [1,nQubits] to end of circuit. Args: n_circuits (int): Number of circuits to add. do_measure (bool): Whether to add measurements. basis (list(str) or None): List of op names. If None, basis is randomly chosen with unique ops in (2,7) basis_weights (list(float) or None): List of weights corresponding to indices in `basis`. Raises: AttributeError: if operation is not recognized. """ if basis is None: basis = list( random.sample(self.op_signature.keys(), random.randint(2, 7))) basis_weights = [1. / len(basis)] * len(basis) if basis_weights is not None: assert len(basis) == len(basis_weights) uop_basis = basis[:] if basis_weights: uop_basis_weights = basis_weights[:] else: uop_basis_weights = None # remove barrier from uop basis if it is specified if 'barrier' in uop_basis: ind = uop_basis.index('barrier') del uop_basis[ind] if uop_basis_weights: del uop_basis_weights[ind] # remove measure from uop basis if it is specified if 'measure' in uop_basis: ind = uop_basis.index('measure') del uop_basis[ind] if uop_basis_weights: del uop_basis_weights[ind] # self.basis_gates = uop_basis self.basis_gates = basis self.circuit_name_list = [] # TODO: replace choices with random.choices() when python 3.6 is # required. self.n_qubit_list = choices(range(self.min_qubits, self.max_qubits + 1), k=n_circuits) self.depth_list = choices(range(self.min_depth, self.max_depth + 1), k=n_circuits) for i_circuit in range(n_circuits): n_qubits = self.n_qubit_list[i_circuit] if self.min_regs_exceeds_nqubits(uop_basis, n_qubits): # no gate operation from this circuit can fit in the available # number of qubits. continue depth_cnt = self.depth_list[i_circuit] reg_pop = numpy.arange(1, n_qubits + 1) register_weights = reg_pop[::-1].astype(float) register_weights /= register_weights.sum() max_registers = numpy.random.choice(reg_pop, p=register_weights) reg_weight = numpy.ones(max_registers) / float(max_registers) reg_sizes = rand_register_sizes(n_qubits, reg_weight) n_registers = len(reg_sizes) circuit = QuantumCircuit() for i_size, size in enumerate(reg_sizes): cr_name = 'cr' + str(i_size) qr_name = 'qr' + str(i_size) creg = ClassicalRegister(int(size), cr_name) qreg = QuantumRegister(int(size), qr_name) circuit.add_register(qreg, creg) while depth_cnt > 0: # TODO: replace choices with random.choices() when python 3.6 # is required. op_name = choices(basis, weights=basis_weights)[0] if hasattr(circuit, op_name): operator = getattr(circuit, op_name) else: raise AttributeError('operation \"{0}\"' ' not recognized'.format(op_name)) n_regs = self.op_signature[op_name]['nregs'] n_params = self.op_signature[op_name]['nparams'] if n_regs == 0: # this is a barrier or measure n_regs = random.randint(1, n_qubits) if n_qubits >= n_regs: # warning: assumes op function signature specifies # op parameters before qubits op_args = [] if n_params: op_args = [random.random() for _ in range(n_params)] if op_name == 'measure': # if measure occurs here, assume it's to do a conditional # randomly select a register to measure ireg = random.randint(0, n_registers - 1) qr_name = 'qr' + str(ireg) cr_name = 'cr' + str(ireg) qreg = circuit.regs[qr_name] creg = circuit.regs[cr_name] for qind in range(qreg.size): operator(qreg[qind], creg[qind]) ifval = random.randint(0, (1 << qreg.size) - 1) # TODO: replace choices with random.choices() when # python 3.6 is required. uop_name = choices(uop_basis, weights=uop_basis_weights)[0] if hasattr(circuit, uop_name): uop = getattr(circuit, uop_name) else: raise AttributeError( 'operation \"{0}\"' ' not recognized'.format(uop_name)) unregs = self.op_signature[uop_name]['nregs'] unparams = self.op_signature[uop_name]['nparams'] if unregs == 0: # this is a barrier or measure unregs = random.randint(1, n_qubits) if qreg.size >= unregs: qind_list = random.sample(range(qreg.size), unregs) uop_args = [] if unparams: uop_args = [ random.random() for _ in range(unparams) ] uop_args.extend([qreg[qind] for qind in qind_list]) uop(*uop_args).c_if(creg, ifval) depth_cnt -= 1 elif op_name == 'barrier': ireg = random.randint(0, n_registers - 1) qreg = circuit.qregs[ireg] bar_args = [(qreg, mi) for mi in range(qreg.size)] operator(*bar_args) else: # select random register ireg = random.randint(0, n_registers - 1) qreg = circuit.qregs[ireg] if qreg.size >= n_regs: qind_list = random.sample(range(qreg.size), n_regs) op_args.extend([qreg[qind] for qind in qind_list]) operator(*op_args) depth_cnt -= 1 else: break nmeasure = random.randint(1, n_qubits) m_list = random.sample(range(nmeasure), nmeasure) if do_measure: for qind in m_list: rind = 0 # register index cumtot = 0 while qind >= cumtot + circuit.qregs[rind].size: cumtot += circuit.qregs[rind].size rind += 1 qrind = int(qind - cumtot) qreg = circuit.qregs[rind] creg = circuit.cregs[rind] circuit.measure(qreg[qrind], creg[qrind]) self.circuit_list.append(circuit)
# Each gate and their truth tables will be shown. Here we denote quantum registers as 'q' and classical registers as 'c' where we encode the output of the measurement. # ### NOT Gate # As was mentioned before, an X gate can be considered a NOT gate. The truth table for a NOT gate looks like this: # # # |input|output| # |--|--| # |0|1| # |1|0| # In[12]: # Create a Quantum Circuit with 1 quantum register and 1 classical register q = QuantumRegister(1) c = ClassicalRegister(1) qc = QuantumCircuit(q, c) qc.x(q[0]) qc.measure(q[0], c[0]) # Map the quantum measurement to the classical bits qc.draw(output='mpl') # ### AND Gate # The truth table for an AND Gate looks like this: # # |A (input)|B (input)|output| # |--|--|--| # |0|0|0| # |0|1|0| # |1|0|0| # |1|1|1| #
def test_four(self): encoding_map = FixedLengthQubitEncoding(2, 2) X_train = [[4.4, -9.53], [18.42, 1.0]] y_train = [0, 1] input = [2.043, 13.84] X_train_in_encoded_space = [encoding_map.map(x) for x in X_train] X_train_in_encoded_space_qubit_notation = [[ "{:b}".format(i).zfill(2 * 5) for i, _ in elem.keys() ] for elem in X_train_in_encoded_space] input_in_encoded_space = encoding_map.map(input) input_in_encoded_space_qubit_notation = [ "{:b}".format(i).zfill(2 * 5) for i, _ in input_in_encoded_space.keys() ] logger.info("Training samples in encoded space: {}".format( X_train_in_encoded_space_qubit_notation)) logger.info("Input sample in encoded space: {}".format( input_in_encoded_space_qubit_notation)) circuit = QmlBinaryDataStateCircuitBuilder(CCXToffoli()) qc = circuit.build_circuit('test', X_train=X_train_in_encoded_space, y_train=y_train, X_input=input_in_encoded_space) self.assertIsNotNone(qc) self.assertIsNotNone(qc.data) # TODO: adjust ASAP # self.assertEqual(28, len(qc.data)) # # self.assertListEqual(["h"], [qc.data[0].name]) # self.assertListEqual(["h"], [qc.data[1].name]) # # self.assertListEqual(["x", [], "(QuantumRegister(1, 'a'), 0)"], extract_gate_info(qc, 2)) # self.assertListEqual(["x", [], "(QuantumRegister(1, 'i'), 0)"], extract_gate_info(qc, 3)) # # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 1)"], extract_gate_info(qc, 4)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 3)"], extract_gate_info(qc, 5)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 4)"], extract_gate_info(qc, 6)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 5)"], extract_gate_info(qc, 7)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 8)"], extract_gate_info(qc, 8)) # # self.assertListEqual(["x", [], "(QuantumRegister(1, 'a'), 0)"], extract_gate_info(qc, 9)) # # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 0)"], extract_gate_info(qc, 10)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 1)"], extract_gate_info(qc, 11)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 2)"], extract_gate_info(qc, 12)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 3)"], extract_gate_info(qc, 13)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 8)"], extract_gate_info(qc, 14)) # # self.assertListEqual(["x", [], "(QuantumRegister(1, 'i'), 0)"], extract_gate_info(qc, 15)) # # self.assertListEqual(["x", [], "(QuantumRegister(1, 'a'), 0)"], extract_gate_info(qc, 16)) # # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 2)"], extract_gate_info(qc, 17)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 5)"], extract_gate_info(qc, 18)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 8)"], extract_gate_info(qc, 19)) # self.assertListEqual(["ccx", [], "(QuantumRegister(1, 'l^q'), 0)"], extract_gate_info(qc, 20)) # # self.assertListEqual(["x", [], "(QuantumRegister(1, 'a'), 0)"], extract_gate_info(qc, 21)) # # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 0)"], extract_gate_info(qc, 22)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 1)"], extract_gate_info(qc, 23)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 2)"], extract_gate_info(qc, 24)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 3)"], extract_gate_info(qc, 25)) # self.assertListEqual(["ccx", [], "(QuantumRegister(10, 'f^S'), 8)"], extract_gate_info(qc, 26)) # # self.assertListEqual(["ccx", [], "(QuantumRegister(1, 'l^q'), 0)"], extract_gate_info(qc, 27)) cregs = [ClassicalRegister(qr.size, 'c' + qr.name) for qr in qc.qregs] qc2 = QuantumCircuit(*qc.qregs, *cregs, name='test2') qc2.data = qc.data for i in range(len(qc.qregs)): measure(qc2, qc.qregs[i], cregs[i]) execution_backend = qiskit.Aer.get_backend( 'qasm_simulator') # type: BaseBackend job = qiskit.execute([qc2], execution_backend, shots=8192) counts = job.result().get_counts() # type: dict self.assertListEqual( sorted([ '0 0100111010 0 0', '0 0100001111 0 1', '1 0100100100 1 0', '1 0100001111 1 1' ]), sorted(counts.keys()))
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[1]) # number=29 prog.cz(input_qubit[3],input_qubit[1]) # number=30 prog.h(input_qubit[1]) # number=31 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.h(input_qubit[0]) # number=51 prog.cz(input_qubit[1],input_qubit[0]) # number=52 prog.h(input_qubit[0]) # number=53 prog.h(input_qubit[0]) # number=64 prog.cz(input_qubit[1],input_qubit[0]) # number=65 prog.h(input_qubit[0]) # number=66 prog.x(input_qubit[0]) # number=49 prog.h(input_qubit[0]) # number=57 prog.cz(input_qubit[1],input_qubit[0]) # number=58 prog.h(input_qubit[0]) # number=59 prog.h(input_qubit[0]) # number=54 prog.cz(input_qubit[1],input_qubit[0]) # number=55 prog.h(input_qubit[0]) # number=56 prog.h(input_qubit[4]) # number=41 prog.h(input_qubit[0]) # number=61 prog.cz(input_qubit[1],input_qubit[0]) # number=62 prog.h(input_qubit[0]) # number=63 prog.cx(input_qubit[0],input_qubit[1]) # number=67 prog.x(input_qubit[1]) # number=68 prog.cx(input_qubit[0],input_qubit[1]) # number=69 prog.h(input_qubit[2]) # number=25 prog.cz(input_qubit[0],input_qubit[2]) # number=26 prog.h(input_qubit[2]) # number=27 prog.x(input_qubit[2]) # number=23 prog.cx(input_qubit[0],input_qubit[2]) # number=24 prog.cx(input_qubit[0],input_qubit[3]) # number=32 prog.x(input_qubit[3]) # number=33 prog.h(input_qubit[3]) # number=42 prog.cz(input_qubit[0],input_qubit[3]) # number=43 prog.h(input_qubit[3]) # number=44 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.x(input_qubit[0]) # number=13 prog.rx(0.6157521601035993,input_qubit[1]) # number=60 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
def unitary_gate_circuits_real_deterministic(final_measure=True): """Unitary gate test circuits with deterministic count output.""" final_qobj = _dummy_qobj() qr = QuantumRegister(2) if final_measure: cr = ClassicalRegister(2) regs = (qr, cr) else: regs = (qr, ) x_mat = np.array([[0, 1], [1, 0]]) cx_mat = np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0]]) # CX01, |00> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(cx_mat, [0, 1])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) # CX10, |00> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(cx_mat, [1, 0])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) # CX01.(X^I), |10> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(x_mat, [1])) append_instr(qobj, 0, unitary_instr(cx_mat, [0, 1])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) # CX10.(I^X), |01> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(x_mat, [0])) append_instr(qobj, 0, unitary_instr(cx_mat, [1, 0])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) # CX01.(I^X), |11> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(x_mat, [0])) append_instr(qobj, 0, unitary_instr(cx_mat, [0, 1])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) # CX10.(X^I), |11> state circuit = QuantumCircuit(*regs) circuit.barrier(qr) qobj = compile(circuit, QasmSimulator(), shots=1) append_instr(qobj, 0, unitary_instr(x_mat, [1])) append_instr(qobj, 0, unitary_instr(cx_mat, [1, 0])) if final_measure: append_instr(qobj, 0, measure_instr([0], [0])) append_instr(qobj, 0, measure_instr([1], [1])) final_qobj.experiments.append(qobj.experiments[0]) return final_qobj
def make_circuit(n: int, f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n, "qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.x(input_qubit[1]) # number=48 prog.h(input_qubit[1]) # number=26 prog.cz(input_qubit[4], input_qubit[1]) # number=27 prog.h(input_qubit[1]) # number=28 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[4]) # number=21 prog.h(input_qubit[1]) # number=34 prog.cz(input_qubit[4], input_qubit[1]) # number=35 prog.z(input_qubit[4]) # number=46 prog.rx(0.8011061266653969, input_qubit[2]) # number=37 prog.h(input_qubit[1]) # number=36 Zf = build_oracle(n, f) repeat = floor(sqrt(2**n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[1], input_qubit[0]) # number=38 prog.x(input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1], input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.cx(input_qubit[0], input_qubit[1]) # number=42 prog.x(input_qubit[1]) # number=43 prog.cx(input_qubit[0], input_qubit[1]) # number=44 prog.x(input_qubit[2]) # number=11 prog.y(input_qubit[1]) # number=45 prog.x(input_qubit[3]) # number=12 prog.h(input_qubit[2]) # number=41 if n >= 2: prog.mcu1(pi, input_qubit[1:], input_qubit[0]) prog.cx(input_qubit[1], input_qubit[0]) # number=22 prog.x(input_qubit[4]) # number=47 prog.x(input_qubit[0]) # number=23 prog.cx(input_qubit[1], input_qubit[0]) # number=24 prog.cx(input_qubit[0], input_qubit[1]) # number=30 prog.x(input_qubit[1]) # number=31 prog.cx(input_qubit[0], input_qubit[1]) # number=32 prog.x(input_qubit[2]) # number=15 prog.h(input_qubit[4]) # number=29 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 # circuit end return prog
def cu1_gate_circuits_nondeterministic(final_measure): circuits = [] qr = QuantumRegister(2) if final_measure: cr = ClassicalRegister(2) regs = (qr, cr) else: regs = (qr, ) # H^X.CU1(0,0,1).H^X circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.x(qr[0]) circuit.cu1(0, qr[0], qr[1]) circuit.x(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^I.CU1(pi,0,1).H^I circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.cu1(np.pi, qr[0], qr[1]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^X.CU1(pi/4,0,1).H^X circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.x(qr[0]) circuit.cu1(np.pi / 4, qr[0], qr[1]) circuit.x(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^X.CU1(pi/2,0,1).H^X circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.x(qr[0]) circuit.cu1(np.pi / 2, qr[0], qr[1]) circuit.x(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^X.CU1(pi,0,1).H^X circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.x(qr[0]) circuit.cu1(np.pi, qr[0], qr[1]) circuit.x(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^H.CU1(0,0,1).H^H circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.h(qr[0]) circuit.cu1(0, qr[0], qr[1]) circuit.h(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^H.CU1(pi/2,0,1).H^H circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.h(qr[0]) circuit.cu1(np.pi / 2, qr[0], qr[1]) circuit.h(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) # H^H.CU1(pi,0,1).H^H circuit = QuantumCircuit(*regs) circuit.h(qr[1]) circuit.h(qr[0]) circuit.cu1(np.pi, qr[0], qr[1]) circuit.h(qr[0]) circuit.h(qr[1]) if final_measure: circuit.barrier(qr) circuit.measure(qr, cr) circuits.append(circuit) return circuits
def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.h(input_qubit[0]) # number=3 prog.h(input_qubit[1]) # number=4 prog.h(input_qubit[2]) # number=5 prog.h(input_qubit[3]) # number=6 prog.h(input_qubit[0]) # number=38 prog.cz(input_qubit[1],input_qubit[0]) # number=39 prog.h(input_qubit[0]) # number=40 prog.h(input_qubit[0]) # number=49 prog.cz(input_qubit[1],input_qubit[0]) # number=50 prog.h(input_qubit[0]) # number=51 prog.cx(input_qubit[1],input_qubit[0]) # number=52 prog.z(input_qubit[1]) # number=53 prog.h(input_qubit[0]) # number=55 prog.cz(input_qubit[1],input_qubit[0]) # number=56 prog.h(input_qubit[0]) # number=57 prog.cx(input_qubit[1],input_qubit[0]) # number=47 prog.h(input_qubit[0]) # number=32 prog.cz(input_qubit[1],input_qubit[0]) # number=33 prog.h(input_qubit[0]) # number=34 prog.x(input_qubit[4]) # number=48 prog.h(input_qubit[4]) # number=21 Zf = build_oracle(n, f) repeat = floor(sqrt(2 ** n) * pi / 4) for i in range(repeat): prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)]) prog.h(input_qubit[0]) # number=1 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=8 prog.cx(input_qubit[3],input_qubit[0]) # number=41 prog.z(input_qubit[3]) # number=42 prog.cx(input_qubit[3],input_qubit[0]) # number=43 prog.cx(input_qubit[1],input_qubit[3]) # number=44 prog.x(input_qubit[0]) # number=9 prog.x(input_qubit[1]) # number=10 prog.x(input_qubit[2]) # number=11 prog.cx(input_qubit[0],input_qubit[3]) # number=35 prog.x(input_qubit[3]) # number=36 prog.cx(input_qubit[0],input_qubit[3]) # number=37 if n>=2: prog.mcu1(pi,input_qubit[1:],input_qubit[0]) prog.cx(input_qubit[1],input_qubit[0]) # number=24 prog.x(input_qubit[0]) # number=25 prog.cx(input_qubit[1],input_qubit[0]) # number=26 prog.x(input_qubit[1]) # number=14 prog.x(input_qubit[2]) # number=15 prog.x(input_qubit[3]) # number=16 prog.h(input_qubit[0]) # number=17 prog.h(input_qubit[1]) # number=18 prog.h(input_qubit[2]) # number=19 prog.h(input_qubit[3]) # number=20 prog.x(input_qubit[1]) # number=22 prog.x(input_qubit[1]) # number=23 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog
n = len(index) if not n >= 2: raise ValueError # Create a Quantum Register with 2 qubits. # control quibits q = QuantumRegister(n, 'q') # ancillary qubits anc = QuantumRegister(n - 1, 'anc') # target qubits for oracle (for debuggin) tar = QuantumRegister(1, 'tar') # ancillary qubits for diffusion gate anc_s = QuantumRegister(n - 2, 'anc_S') # target qubits for diffusion gate tar_s = QuantumRegister(1, 'tar_s') # Create a Classical Register for oracle measurements. co = ClassicalRegister(1, 'co') # registers for measurement of the qubits c = ClassicalRegister(n, 'c') # Create a Quantum Circuit qc = QuantumCircuit(q, anc, tar, c, co) # set input for testing for i in range(n): v = int(index[i]) if v != 0: qc.x(q[i]) # apply hadamard gates # for i in range(n): # qc.h(q[i])