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])
