def bitFlipError(stateVector=[], error_probability=0.2):
'''
Quantum circuit to detect single bit flip errors.
Note: Add compatibility of user given arbitrary state vector in the first qubit.
'''
q = QuantumRegister(3, name='q')
c = ClassicalRegister(3, name='c')
qc = QuantumCircuit(q, c, name='bit_flip_circuit')
# Brings the 3 qubit system to the state (a*|000> + b*|111>). a=b=1/sqrt(2)
if stateVector == []:
qc.h(q[0])
else:
desired_vector = stateVector
qc.initialize(desired_vector, [q[0]])
qc.cx(q[0], q[1])
qc.cx(q[0], q[2])
# Random bit flip error with a probability of 0.2
ind = random.randint(0, 2)
if random.random() <= error_probability:
print("Bit number {} flipped due to noise".format(ind + 1))
qc.x(q[ind])
ancilla = QuantumRegister(2, name='a')
classical_ancilla = ClassicalRegister(2, name='ca')
qc.add(ancilla)
qc.add(classical_ancilla)
qc.cx(q[0], ancilla[0])
qc.cx(q[1], ancilla[0])
qc.cx(q[0], ancilla[1])
qc.cx(q[2], ancilla[1])
qc.measure(ancilla, classical_ancilla)
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
print("Finding bit flip error: ", result_sim)
print(result_sim.get_counts(qc))
error_bit = list(result_sim.get_counts().keys())[0].split()[0]
if error_bit == '11':
print("Bit-flip error in the first bit")
qc.x(q[0])
elif error_bit == '01':
print("Bit-flip error in second bit")
qc.x(q[1])
elif error_bit == '10':
print("Bit-flip error in third bit")
qc.x(q[2])
else:
print("No bit-flip error in the code.")
return q, c, qc
def get_controlled_circuit(circuit, ctl_qubit, tgt_circuit=None, use_basis_gates=True):
"""
Construct the controlled version of a given circuit.
Args:
circuit (QuantumCircuit) : the base circuit
ctl_qubit (indexed QuantumRegister) : the control qubit to use
tgt_circuit (QuantumCircuit) : the target controlled circuit to be modified in-place
use_basis_gates (bool) : boolean flag to indicate whether or not only basis gates should be used
Return:
a QuantumCircuit object with the base circuit being controlled by ctl_qubit
"""
if tgt_circuit is not None:
qc = tgt_circuit
else:
qc = QuantumCircuit()
# get all the qubits and clbits
qregs = circuit.get_qregs()
qubits = []
for name in qregs:
if not qc.has_register(qregs[name]):
qc.add(qregs[name])
qubits.extend(qregs[name])
cregs = circuit.get_cregs()
clbits = []
for name in cregs:
if not qc.has_register(cregs[name]):
qc.add(cregs[name])
clbits.extend(cregs[name])
# get all operations from compiled circuit
ops = transpiler.compile(
circuit,
Aer.get_backend('local_qasm_simulator'),
basis_gates='u1,u2,u3,cx,id'
)['circuits'][0]['compiled_circuit']['operations']
# process all basis gates to add control
if not qc.has_register(ctl_qubit[0]):
qc.add(ctl_qubit[0])
for op in ops:
if op['name'] == 'id':
apply_cu3(qc, 0, 0, 0, ctl_qubit, qubits[op['qubits'][0]], use_basis_gates=use_basis_gates)
elif op['name'] == 'u1':
apply_cu1(qc, *op['params'], ctl_qubit, qubits[op['qubits'][0]], use_basis_gates=use_basis_gates)
elif op['name'] == 'u2':
apply_cu3(qc, np.pi / 2, *op['params'], ctl_qubit, qubits[op['qubits'][0]], use_basis_gates=use_basis_gates)
elif op['name'] == 'u3':
apply_cu3(qc, *op['params'], ctl_qubit, qubits[op['qubits'][0]], use_basis_gates=use_basis_gates)
elif op['name'] == 'cx':
apply_ccx(qc, ctl_qubit, *[qubits[i] for i in op['qubits']], use_basis_gates=use_basis_gates)
elif op['name'] == 'measure':
qc.measure(qubits[op['qubits'][0]], clbits[op['clbits'][0]])
else:
raise RuntimeError('Unexpected operation {}.'.format(op['name']))
return qc
def Grover_search(arr):
n = 3
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(n + 1)
ans = ClassicalRegister(n)
grover = QuantumCircuit()
grover.add(f_in)
grover.add(f_out)
grover.add(aux)
grover.add(ans)
predefined_index = get_predefine_index(arr)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
oracle(grover, f_in, f_out, aux, n, predefined_index)
inversion_about_average(grover, f_in, n)
for j in range(n):
grover.measure(f_in[j], ans[j])
backend = Aer.get_backend('qasm_simulator')
job = execute([grover], backend=backend, shots=1000)
result = job.result()
counts = result.get_counts(grover)
inv = [(value, key) for key, value in counts.items()]
outstr = str(max(inv)[1])
ind = 0
for i in range(len(outstr)):
if outstr[i] == '1':
ind = ind * 2 + 1
else:
ind = ind * 2
# print(ind)
# print(arr[ind])
return ind
#return arr[ind]
#visualization.plot_histogram(counts)
# a = [1, 2, 0, 4, 5]
# Grover_search(a)
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(cr_name, size)
qreg = QuantumRegister(qr_name, size)
circuit.add(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)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
bar_args = [(qreg, mi) for mi in range(qreg.size)]
operator(*bar_args)
else:
# select random register
ireg = random.randint(0, n_registers - 1)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
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.regs['qr' + str(rind)].size:
cumtot += circuit.regs['qr' + str(rind)].size
rind += 1
qrind = int(qind - cumtot)
qreg = circuit.regs['qr' + str(rind)]
creg = circuit.regs['cr' + str(rind)]
circuit.measure(qreg[qrind], creg[qrind])
self.circuit_list.append(circuit)
def add_circuits(self, nCircuits, doMeasure=True, basis=['u3', 'cx'],
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:
nCircuits (int): Number of circuits to add.
doMeasure (bool): Whether to add measurements.
basis (list of str): List of op names.
basis_weights (list of float or None): List of weights
corresponding to indices in `basis`.
"""
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.circuitNameList = []
# TODO: replace choices with random.choices() when python 3.6 is
# required.
self.nQubit_list = choices(
range(self.minQubits, self.maxQubits+1), k=nCircuits)
self.depth_list = choices(
range(self.minDepth, self.maxDepth+1), k=nCircuits)
for iCircuit in range(nCircuits):
nQubits = self.nQubit_list[iCircuit]
depthCnt = self.depth_list[iCircuit]
regpop = numpy.arange(1, nQubits+1)
registerWeights = regpop[::-1].astype(float)
registerWeights /= registerWeights.sum()
maxRegisters = numpy.random.choice(regpop, p=registerWeights)
regWeight = numpy.ones(maxRegisters) / float(maxRegisters)
regSizes = rand_register_sizes(nQubits, regWeight)
nRegisters = len(regSizes)
circuit = QuantumCircuit()
for isize, size in enumerate(regSizes):
cr_name = 'cr' + str(isize)
qr_name = 'qr' + str(isize)
cr = ClassicalRegister(cr_name, size)
qr = QuantumRegister(qr_name, size)
circuit.add(qr, cr)
while depthCnt > 0:
# TODO: replace choices with random.choices() when python 3.6
# is required.
opName = choices(basis, weights=basis_weights)[0]
if hasattr(circuit, opName):
op = getattr(circuit, opName)
else:
raise AttributeError('operation \"{0}\"'
' not recognized'.format(opName))
nregs = self.opSignature[opName]['nregs']
nparams = self.opSignature[opName]['nparams']
if nregs == 0: # this is a barrier or measure
nregs = random.randint(1, nQubits)
if nQubits >= nregs:
# warning: assumes op function signature specifies
# op parameters before qubits
op_args = []
if nparams:
op_args = [random.random() for p in range(nparams)]
if opName is 'measure':
# if measure occurs here, assume it's to do a conditional
# randomly select a register to measure
ireg = random.randint(0, nRegisters-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):
op(qreg[qind], creg[qind])
ifval = random.randint(0, (1 << qreg.size) - 1)
# TODO: replace choices with random.choices() when
# python 3.6 is required.
uopName = choices(uop_basis, weights=uop_basis_weights)[0]
if hasattr(circuit, uopName):
uop = getattr(circuit, uopName)
else:
raise AttributeError('operation \"{0}\"'
' not recognized'.format(uopName))
unregs = self.opSignature[uopName]['nregs']
unparams = self.opSignature[uopName]['nparams']
if unregs == 0: # this is a barrier or measure
unregs = random.randint(1, nQubits)
if qreg.size >= unregs:
qindList = random.sample(range(qreg.size), unregs)
uop_args = []
if unparams:
uop_args = [random.random() for p in range(unparams)]
uop_args.extend([qreg[qind] for qind in qindList])
uop(*uop_args).c_if(creg, ifval)
depthCnt -= 1
elif opName is 'barrier':
ireg = random.randint(0, nRegisters-1)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
bar_args = [(qreg, mi) for mi in range(qreg.size)]
op(*bar_args)
else:
# select random register
ireg = random.randint(0, nRegisters-1)
qr_name = 'qr' + str(ireg)
try:
qreg = circuit.regs[qr_name]
except Exception as e:
print(e)
import pdb;pdb.set_trace()
if qreg.size >= nregs:
qindList = random.sample(range(qreg.size), nregs)
op_args.extend([qreg[qind] for qind in qindList])
op(*op_args)
depthCnt -= 1
nmeasure = random.randint(1, nQubits)
mList = random.sample(range(nmeasure), nmeasure)
if doMeasure:
for qind in mList:
rind = 0 # register index
cumtot = 0
while qind >= cumtot + circuit.regs['qr' + str(rind)].size:
cumtot += circuit.regs['qr' + str(rind)].size
rind += 1
qrind = int(qind - cumtot)
qreg = circuit.regs['qr'+str(rind)]
creg = circuit.regs['cr'+str(rind)]
try:
circuit.measure(qreg[qrind], creg[qrind])
except Exception as e:
print(e)
print(qrind)
import pdb;pdb.set_trace()
self.circuit_list.append(circuit)
def add_circuits(self,
nCircuits,
doMeasure=True,
basis=['u3', 'cx'],
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:
nCircuits (int): Number of circuits to add.
doMeasure (bool): Whether to add measurements.
basis (list of str): List of op names.
basis_weights (list of float or None): List of weights
corresponding to indices in `basis`.
"""
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.circuitNameList = []
# TODO: replace choices with random.choices() when python 3.6 is
# required.
self.nQubit_list = choices(range(self.minQubits, self.maxQubits + 1),
k=nCircuits)
self.depth_list = choices(range(self.minDepth, self.maxDepth + 1),
k=nCircuits)
for iCircuit in range(nCircuits):
nQubits = self.nQubit_list[iCircuit]
depthCnt = self.depth_list[iCircuit]
regpop = numpy.arange(1, nQubits + 1)
registerWeights = regpop[::-1].astype(float)
registerWeights /= registerWeights.sum()
maxRegisters = numpy.random.choice(regpop, p=registerWeights)
regWeight = numpy.ones(maxRegisters) / float(maxRegisters)
regSizes = rand_register_sizes(nQubits, regWeight)
nRegisters = len(regSizes)
circuit = QuantumCircuit()
for isize, size in enumerate(regSizes):
cr_name = 'cr' + str(isize)
qr_name = 'qr' + str(isize)
cr = ClassicalRegister(cr_name, size)
qr = QuantumRegister(qr_name, size)
circuit.add(qr, cr)
while depthCnt > 0:
# TODO: replace choices with random.choices() when python 3.6
# is required.
opName = choices(basis, weights=basis_weights)[0]
if hasattr(circuit, opName):
op = getattr(circuit, opName)
else:
raise AttributeError('operation \"{0}\"'
' not recognized'.format(opName))
nregs = self.opSignature[opName]['nregs']
nparams = self.opSignature[opName]['nparams']
if nregs == 0: # this is a barrier or measure
nregs = random.randint(1, nQubits)
if nQubits >= nregs:
# warning: assumes op function signature specifies
# op parameters before qubits
op_args = []
if nparams:
op_args = [random.random() for p in range(nparams)]
if opName is 'measure':
# if measure occurs here, assume it's to do a conditional
# randomly select a register to measure
ireg = random.randint(0, nRegisters - 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):
op(qreg[qind], creg[qind])
ifval = random.randint(0, (1 << qreg.size) - 1)
# TODO: replace choices with random.choices() when
# python 3.6 is required.
uopName = choices(uop_basis,
weights=uop_basis_weights)[0]
if hasattr(circuit, uopName):
uop = getattr(circuit, uopName)
else:
raise AttributeError(
'operation \"{0}\"'
' not recognized'.format(uopName))
unregs = self.opSignature[uopName]['nregs']
unparams = self.opSignature[uopName]['nparams']
if unregs == 0: # this is a barrier or measure
unregs = random.randint(1, nQubits)
if qreg.size >= unregs:
qindList = random.sample(range(qreg.size), unregs)
uop_args = []
if unparams:
uop_args = [
random.random() for p in range(unparams)
]
uop_args.extend([qreg[qind] for qind in qindList])
uop(*uop_args).c_if(creg, ifval)
depthCnt -= 1
elif opName is 'barrier':
ireg = random.randint(0, nRegisters - 1)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
bar_args = [(qreg, mi) for mi in range(qreg.size)]
op(*bar_args)
else:
# select random register
ireg = random.randint(0, nRegisters - 1)
qr_name = 'qr' + str(ireg)
try:
qreg = circuit.regs[qr_name]
except Exception as e:
print(e)
import pdb
pdb.set_trace()
if qreg.size >= nregs:
qindList = random.sample(range(qreg.size), nregs)
op_args.extend([qreg[qind] for qind in qindList])
op(*op_args)
depthCnt -= 1
nmeasure = random.randint(1, nQubits)
mList = random.sample(range(nmeasure), nmeasure)
if doMeasure:
for qind in mList:
rind = 0 # register index
cumtot = 0
while qind >= cumtot + circuit.regs['qr' + str(rind)].size:
cumtot += circuit.regs['qr' + str(rind)].size
rind += 1
qrind = int(qind - cumtot)
qreg = circuit.regs['qr' + str(rind)]
creg = circuit.regs['cr' + str(rind)]
try:
circuit.measure(qreg[qrind], creg[qrind])
except Exception as e:
print(e)
print(qrind)
import pdb
pdb.set_trace()
self.circuit_list.append(circuit)
def get_controlled_circuit(circuit,
ctl_qubit,
tgt_circuit=None,
use_basis_gates=True):
"""
Construct the controlled version of a given circuit.
Args:
circuit (QuantumCircuit) : the base circuit
ctl_qubit (indexed QuantumRegister) : the control qubit to use
tgt_circuit (QuantumCircuit) : the target controlled circuit to be modified in-place
use_basis_gates (bool) : boolean flag to indicate whether or not only basis gates should be used
Return:
a QuantumCircuit object with the base circuit being controlled by ctl_qubit
"""
if tgt_circuit is not None:
qc = tgt_circuit
else:
qc = QuantumCircuit()
# get all the qubits and clbits
qregs = circuit.qregs
qubits = []
for qreg in qregs:
if not qc.has_register(qreg):
qc.add_register(qreg)
qubits.extend(qreg)
cregs = circuit.cregs
clbits = []
for creg in cregs:
if not qc.has_register(creg):
qc.add_register(creg)
clbits.extend(creg)
# get all operations from compiled circuit
unroller = Unroller(basis=['u1', 'u2', 'u3', 'cx', 'id'])
pm = PassManager(passes=[unroller])
ops = compiler.transpile(circuit,
BasicAer.get_backend('qasm_simulator'),
pass_manager=pm).data
# process all basis gates to add control
if not qc.has_register(ctl_qubit[0]):
qc.add(ctl_qubit[0])
for op in ops:
if op[0].name == 'id':
apply_cu3(qc,
0,
0,
0,
ctl_qubit,
op[1][0],
use_basis_gates=use_basis_gates)
elif op[0].name == 'u1':
apply_cu1(qc,
*op[0].params,
ctl_qubit,
op[1][0],
use_basis_gates=use_basis_gates)
elif op[0].name == 'u2':
apply_cu3(qc,
np.pi / 2,
*op[0].params,
ctl_qubit,
op[1][0],
use_basis_gates=use_basis_gates)
elif op[0].name == 'u3':
apply_cu3(qc,
*op[0].params,
ctl_qubit,
op[1][0],
use_basis_gates=use_basis_gates)
elif op[0].name == 'cx':
apply_ccx(qc, ctl_qubit, *op[1], use_basis_gates=use_basis_gates)
elif op[0].name == 'measure':
qc.measure(op[1], op[2])
else:
raise RuntimeError('Unexpected operation {}.'.format(op['name']))
return qc
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(size, cr_name)
qreg = QuantumRegister(size, qr_name)
circuit.add(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)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
bar_args = [(qreg, mi) for mi in range(qreg.size)]
operator(*bar_args)
else:
# select random register
ireg = random.randint(0, n_registers-1)
qr_name = 'qr' + str(ireg)
qreg = circuit.regs[qr_name]
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.regs['qr' + str(rind)].size:
cumtot += circuit.regs['qr' + str(rind)].size
rind += 1
qrind = int(qind - cumtot)
qreg = circuit.regs['qr'+str(rind)]
creg = circuit.regs['cr'+str(rind)]
circuit.measure(qreg[qrind], creg[qrind])
self.circuit_list.append(circuit)
class CircuitBackend(UnrollerBackend):
"""Backend for the unroller that produces a QuantumCircuit.
By default, basis gates are the QX gates.
"""
def __init__(self, basis=None):
"""Setup this backend.
basis is a list of operation name strings.
"""
super().__init__(basis)
self.creg = None
self.cval = None
if basis:
self.basis = basis
else:
self.basis = ["cx", "u1", "u2", "u3"]
self.gates = {}
self.listen = True
self.in_gate = ""
self.circuit = QuantumCircuit()
def set_basis(self, basis):
"""Declare the set of user-defined gates to emit.
basis is a list of operation name strings.
"""
self.basis = basis
def version(self, version):
"""Ignore the version string.
v is a version number.
"""
pass
def new_qreg(self, name, size):
"""Create a new quantum register.
name = name of the register
sz = size of the register
"""
assert size >= 0, "invalid qreg size"
q_register = QuantumRegister(size, name)
self.circuit.add(q_register)
def new_creg(self, name, size):
"""Create a new classical register.
name = name of the register
sz = size of the register
"""
assert size >= 0, "invalid creg size"
c_register = ClassicalRegister(size, name)
self.circuit.add(c_register)
def define_gate(self, name, gatedata):
"""Define a new quantum gate.
We don't check that the definition and name agree.
name is a string.
gatedata is the AST node for the gate.
"""
self.gates[name] = gatedata
def _map_qubit(self, qubit):
"""Map qubit tuple (regname, index) to (QuantumRegister, index)."""
qregs = self.circuit.get_qregs()
if qubit[0] not in qregs:
raise BackendError("qreg %s does not exist" % qubit[0])
return (qregs[qubit[0]], qubit[1])
def _map_bit(self, bit):
"""Map bit tuple (regname, index) to (ClassicalRegister, index)."""
cregs = self.circuit.get_cregs()
if bit[0] not in cregs:
raise BackendError("creg %s does not exist" % bit[0])
return (cregs[bit[0]], bit[1])
def _map_creg(self, creg):
"""Map creg name to ClassicalRegister."""
cregs = self.circuit.get_cregs()
if creg not in cregs:
raise BackendError("creg %s does not exist" % creg)
return cregs[creg]
def u(self, arg, qubit, nested_scope=None):
"""Fundamental single qubit gate.
arg is 3-tuple of Node expression objects.
qubit is (regname,idx) tuple.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if self.listen:
if "U" not in self.basis:
self.basis.append("U")
(theta, phi, lam) = list(map(lambda x: x.sym(nested_scope), arg))
this_gate = self.circuit.u_base(theta, phi, lam,
self._map_qubit(qubit))
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def cx(self, qubit0, qubit1):
"""Fundamental two qubit gate.
qubit0 is (regname,idx) tuple for the control qubit.
qubit1 is (regname,idx) tuple for the target qubit.
"""
if self.listen:
if "CX" not in self.basis:
self.basis.append("CX")
this_gate = self.circuit.cx_base(self._map_qubit(qubit0),
self._map_qubit(qubit1))
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def measure(self, qubit, bit):
"""Measurement operation.
qubit is (regname, idx) tuple for the input qubit.
bit is (regname, idx) tuple for the output bit.
"""
if "measure" not in self.basis:
self.basis.append("measure")
this_op = self.circuit.measure(self._map_qubit(qubit),
self._map_bit(bit))
if self.creg is not None:
this_op.c_if(self._map_creg(self.creg), self.cval)
def barrier(self, qubitlists):
"""Barrier instruction.
qubitlists is a list of lists of (regname, idx) tuples.
"""
if self.listen:
if "barrier" not in self.basis:
self.basis.append("barrier")
flatlist = map(
self._map_qubit,
[qubit for qubitlist in qubitlists for qubit in qubitlist])
self.circuit.barrier(*list(flatlist))
def reset(self, qubit):
"""Reset instruction.
qubit is a (regname, idx) tuple.
"""
if "reset" not in self.basis:
self.basis.append("reset")
this_op = self.circuit.reset(self._map_qubit(qubit))
if self.creg is not None:
this_op.c_if(self._map_creg(self.creg), self.cval)
def set_condition(self, creg, cval):
"""Attach a current condition.
creg is a name string.
cval is the integer value for the test.
"""
self.creg = creg
self.cval = cval
def drop_condition(self):
"""Drop the current condition."""
self.creg = None
self.cval = None
def start_gate(self, name, args, qubits, nested_scope=None):
"""Begin a custom gate.
name is name string.
args is list of Node expression objects.
qubits is list of (regname, idx) tuples.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if self.listen and name not in self.basis \
and self.gates[name]["opaque"]:
raise BackendError("opaque gate %s not in basis" % name)
if self.listen and name in self.basis:
self.in_gate = name
self.listen = False
# Gate names mapped to number of arguments and qubits
# and method to invoke on [args, qubits]
lut = {
"ccx": [(0, 3),
lambda x: self.circuit.ccx(x[1][0], x[1][1], x[1][2])],
"ch": [(0, 2), lambda x: self.circuit.ch(x[1][0], x[1][1])],
"crz": [(1, 2),
lambda x: self.circuit.crz(x[0][0], x[1][0], x[1][1])],
"cswap":
[(0, 3),
lambda x: self.circuit.cswap(x[1][0], x[1][1], x[1][2])],
"cu1": [(1, 2),
lambda x: self.circuit.cu1(x[0][0], x[1][0], x[1][1])],
"cu3": [(3, 2), lambda x: self.circuit.cu3(
x[0][0], x[0][1], x[0][2], x[1][0], x[1][1])],
"cx": [(0, 2), lambda x: self.circuit.cx(x[1][0], x[1][1])],
"cy": [(0, 2), lambda x: self.circuit.cy(x[1][0], x[1][1])],
"cz": [(0, 2), lambda x: self.circuit.cz(x[1][0], x[1][1])],
"swap": [(0, 2),
lambda x: self.circuit.swap(x[1][0], x[1][1])],
"h": [(0, 1), lambda x: self.circuit.h(x[1][0])],
"id": [(0, 1), lambda x: self.circuit.iden(x[1][0])],
"rx": [(1, 1), lambda x: self.circuit.rx(x[0][0], x[1][0])],
"ry": [(1, 1), lambda x: self.circuit.ry(x[0][0], x[1][0])],
"rz": [(1, 1), lambda x: self.circuit.rz(x[0][0], x[1][0])],
"s": [(0, 1), lambda x: self.circuit.s(x[1][0])],
"sdg": [(0, 1), lambda x: self.circuit.s(x[1][0]).inverse()],
"t": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()],
"tdg": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()],
"u1": [(1, 1), lambda x: self.circuit.u1(x[0][0], x[1][0])],
"u2": [(2, 1),
lambda x: self.circuit.u2(x[0][0], x[0][1], x[1][0])],
"u3":
[(3, 1),
lambda x: self.circuit.u3(x[0][0], x[0][1], x[0][2], x[1][0])
],
"x": [(0, 1), lambda x: self.circuit.x(x[1][0])],
"y": [(0, 1), lambda x: self.circuit.y(x[1][0])],
"z": [(0, 1), lambda x: self.circuit.z(x[1][0])]
}
if name not in lut:
raise BackendError("gate %s not in standard extensions" % name)
gate_data = lut[name]
if gate_data[0] != (len(args), len(qubits)):
raise BackendError("gate %s signature (%d, %d) is " %
(name, len(args), len(qubits)) +
"incompatible with the standard " +
"extensions")
this_gate = gate_data[1]([
list(map(lambda x: x.sym(nested_scope), args)),
list(map(self._map_qubit, qubits))
])
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def end_gate(self, name, args, qubits, nested_scope=None):
"""End a custom gate.
name is name string.
args is list of Node expression objects.
qubits is list of (regname, idx) tuples.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if name == self.in_gate:
self.in_gate = ""
self.listen = True
def get_output(self):
"""Return the QuantumCircuit object."""
return self.circuit
class CircuitBackend(UnrollerBackend):
"""Backend for the unroller that produces a QuantumCircuit.
By default, basis gates are the QX gates.
"""
def __init__(self, basis=None):
"""Setup this backend.
basis is a list of operation name strings.
"""
super().__init__(basis)
self.creg = None
self.cval = None
if basis:
self.basis = basis
else:
self.basis = ["cx", "u1", "u2", "u3"]
self.gates = {}
self.listen = True
self.in_gate = ""
self.circuit = QuantumCircuit()
def set_basis(self, basis):
"""Declare the set of user-defined gates to emit.
basis is a list of operation name strings.
"""
self.basis = basis
def version(self, version):
"""Ignore the version string.
v is a version number.
"""
pass
def new_qreg(self, name, size):
"""Create a new quantum register.
name = name of the register
sz = size of the register
"""
assert size >= 0, "invalid qreg size"
q_register = QuantumRegister(size, name)
self.circuit.add(q_register)
def new_creg(self, name, size):
"""Create a new classical register.
name = name of the register
sz = size of the register
"""
assert size >= 0, "invalid creg size"
c_register = ClassicalRegister(size, name)
self.circuit.add(c_register)
def define_gate(self, name, gatedata):
"""Define a new quantum gate.
We don't check that the definition and name agree.
name is a string.
gatedata is the AST node for the gate.
"""
self.gates[name] = gatedata
def _map_qubit(self, qubit):
"""Map qubit tuple (regname, index) to (QuantumRegister, index)."""
qregs = self.circuit.get_qregs()
if qubit[0] not in qregs:
raise BackendError("qreg %s does not exist" % qubit[0])
return (qregs[qubit[0]], qubit[1])
def _map_bit(self, bit):
"""Map bit tuple (regname, index) to (ClassicalRegister, index)."""
cregs = self.circuit.get_cregs()
if bit[0] not in cregs:
raise BackendError("creg %s does not exist" % bit[0])
return (cregs[bit[0]], bit[1])
def _map_creg(self, creg):
"""Map creg name to ClassicalRegister."""
cregs = self.circuit.get_cregs()
if creg not in cregs:
raise BackendError("creg %s does not exist" % creg)
return cregs[creg]
def u(self, arg, qubit, nested_scope=None):
"""Fundamental single qubit gate.
arg is 3-tuple of Node expression objects.
qubit is (regname,idx) tuple.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if self.listen:
if "U" not in self.basis:
self.basis.append("U")
(theta, phi, lam) = list(map(lambda x: x.sym(nested_scope), arg))
this_gate = self.circuit.u_base(theta, phi, lam,
self._map_qubit(qubit))
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def cx(self, qubit0, qubit1):
"""Fundamental two qubit gate.
qubit0 is (regname,idx) tuple for the control qubit.
qubit1 is (regname,idx) tuple for the target qubit.
"""
if self.listen:
if "CX" not in self.basis:
self.basis.append("CX")
this_gate = self.circuit.cx_base(self._map_qubit(qubit0),
self._map_qubit(qubit1))
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def measure(self, qubit, bit):
"""Measurement operation.
qubit is (regname, idx) tuple for the input qubit.
bit is (regname, idx) tuple for the output bit.
"""
if "measure" not in self.basis:
self.basis.append("measure")
this_op = self.circuit.measure(self._map_qubit(qubit),
self._map_bit(bit))
if self.creg is not None:
this_op.c_if(self._map_creg(self.creg), self.cval)
def barrier(self, qubitlists):
"""Barrier instruction.
qubitlists is a list of lists of (regname, idx) tuples.
"""
if self.listen:
if "barrier" not in self.basis:
self.basis.append("barrier")
flatlist = map(self._map_qubit,
[qubit for qubitlist in qubitlists
for qubit in qubitlist])
self.circuit.barrier(*list(flatlist))
def reset(self, qubit):
"""Reset instruction.
qubit is a (regname, idx) tuple.
"""
if "reset" not in self.basis:
self.basis.append("reset")
this_op = self.circuit.reset(self._map_qubit(qubit))
if self.creg is not None:
this_op.c_if(self._map_creg(self.creg), self.cval)
def set_condition(self, creg, cval):
"""Attach a current condition.
creg is a name string.
cval is the integer value for the test.
"""
self.creg = creg
self.cval = cval
def drop_condition(self):
"""Drop the current condition."""
self.creg = None
self.cval = None
def start_gate(self, name, args, qubits, nested_scope=None):
"""Begin a custom gate.
name is name string.
args is list of Node expression objects.
qubits is list of (regname, idx) tuples.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if self.listen and name not in self.basis \
and self.gates[name]["opaque"]:
raise BackendError("opaque gate %s not in basis" % name)
if self.listen and name in self.basis:
self.in_gate = name
self.listen = False
# Gate names mapped to number of arguments and qubits
# and method to invoke on [args, qubits]
lut = {"ccx": [(0, 3),
lambda x: self.circuit.ccx(x[1][0], x[1][1],
x[1][2])],
"ch": [(0, 2),
lambda x: self.circuit.ch(x[1][0], x[1][1])],
"crz": [(1, 2),
lambda x: self.circuit.crz(x[0][0], x[1][0],
x[1][1])],
"cswap": [(0, 3),
lambda x: self.circuit.cswap(x[1][0],
x[1][1],
x[1][2])],
"cu1": [(1, 2),
lambda x: self.circuit.cu1(x[0][0], x[1][0],
x[1][1])],
"cu3": [(3, 2), lambda x: self.circuit.cu3(x[0][0],
x[0][1],
x[0][2],
x[1][0],
x[1][1])],
"cx": [(0, 2), lambda x: self.circuit.cx(x[1][0], x[1][1])],
"cy": [(0, 2), lambda x: self.circuit.cy(x[1][0], x[1][1])],
"cz": [(0, 2), lambda x: self.circuit.cz(x[1][0], x[1][1])],
"swap": [(0, 2), lambda x: self.circuit.swap(x[1][0], x[1][1])],
"h": [(0, 1), lambda x: self.circuit.h(x[1][0])],
"id": [(0, 1), lambda x: self.circuit.iden(x[1][0])],
"rx": [(1, 1), lambda x: self.circuit.rx(x[0][0], x[1][0])],
"ry": [(1, 1), lambda x: self.circuit.ry(x[0][0], x[1][0])],
"rz": [(1, 1), lambda x: self.circuit.rz(x[0][0], x[1][0])],
"s": [(0, 1), lambda x: self.circuit.s(x[1][0])],
"sdg": [(0, 1), lambda x: self.circuit.s(x[1][0]).inverse()],
"t": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()],
"tdg": [(0, 1), lambda x: self.circuit.t(x[1][0]).inverse()],
"u1": [(1, 1), lambda x: self.circuit.u1(x[0][0], x[1][0])],
"u2": [(2, 1), lambda x: self.circuit.u2(x[0][0], x[0][1],
x[1][0])],
"u3": [(3, 1), lambda x: self.circuit.u3(x[0][0], x[0][1],
x[0][2], x[1][0])],
"x": [(0, 1), lambda x: self.circuit.x(x[1][0])],
"y": [(0, 1), lambda x: self.circuit.y(x[1][0])],
"z": [(0, 1), lambda x: self.circuit.z(x[1][0])]}
if name not in lut:
raise BackendError("gate %s not in standard extensions" %
name)
gate_data = lut[name]
if gate_data[0] != (len(args), len(qubits)):
raise BackendError("gate %s signature (%d, %d) is " %
(name, len(args), len(qubits)) +
"incompatible with the standard " +
"extensions")
this_gate = gate_data[1]([list(map(lambda x:
x.sym(nested_scope), args)),
list(map(self._map_qubit, qubits))])
if self.creg is not None:
this_gate.c_if(self._map_creg(self.creg), self.cval)
def end_gate(self, name, args, qubits, nested_scope=None):
"""End a custom gate.
name is name string.
args is list of Node expression objects.
qubits is list of (regname, idx) tuples.
nested_scope is a list of dictionaries mapping expression variables
to Node expression objects in order of increasing nesting depth.
"""
if name == self.in_gate:
self.in_gate = ""
self.listen = True
def get_output(self):
"""Return the QuantumCircuit object."""
return self.circuit
class Experiment:
""" Experiment class for defining config, connecting to IBMQ and setting up quantum circuit. """
def __init__(self, backend=None, shots=1024):
try:
register(Qconfig.APItoken, Qconfig.config['url'])
print("Successfully connected to IBMQ.")
except ConnectionError as e:
print(
"{}\n\nFailed to connect to IBMQ - only local simulations are possible."
.format(e))
self.backend = backend
self.shots = shots
self.register_initialised = False
self.qc_initialised = False
self.coupling_map = False
self.results = False
def connect_to_IBM(self, verify=False):
""" Connect to IMB quantum experience using the class token value and config. """
self.api = IBMQuantumExperience(Qconfig.APItoken,
Qconfig.config,
verify=verify)
def create_registers(self, qubits=2, classical_bits=2):
""" Create the quantum and classical registers with the specified number of bits. """
if qubits != classical_bits:
print(
"Warning: number of quantum register bits does not equal classical "
)
self.q = QuantumRegister(qubits)
self.c = [ClassicalRegister(1) for _ in range(classical_bits)]
self.register_initialised = True
def create_quantum_circuit(self):
""" Initialise the quantum circuit if the quantum and classical registers have been initialised. """
if self.register_initialised:
self.qc = QuantumCircuit(self.q)
for c in self.c:
self.qc.add(c)
self.qc_initialised = True
else:
print("Create quantum and classical registers first!")
def bell_state(self, control_qubit=0, target_qubit=1):
""" Create a bell state of specified qubits from an Experiment object. """
if not self.qc_initialised:
print("Initialise quantum circuit first.")
return
try:
control_qubit = self.q[control_qubit]
target_qubit = self.q[target_qubit]
except:
print("Initialising control and target qubits failed")
return
self.qc.h(control_qubit)
self.qc.cx(control_qubit, target_qubit)
self.qc.barrier(self.q)
def single_qubit_gate(self, gate, qubit, angles=[0, 0, 0]):
""" Adding a one qubit gate to the quantum circuit """
gate = str(gate).lower()
if not self.qc_initialised:
print("Initialise quantum circuit first.")
return
try:
qubit = self.q[qubit]
except:
print("Initialising control and target qubits failed")
return
if gate == 'h' or gate == 'hadamard':
self.qc.h(qubit)
elif gate == 'x':
self.qc.x(qubit)
elif gate == 'y':
self.qc.y(qubit)
elif gate == 'z':
self.qc.z(qubit)
elif gate == 'u1':
self.qc.u1(angles[0], qubit)
elif gate == 'u2':
self.qc.u2(angles[0], angles[1], qubit)
elif gate == 'u3':
self.qc.u3(angles[0], angles[1], angles[2], qubit)
else:
print(
"Not a valid single qubit gate. Gate not added to the circuit."
)
def two_qubit_gate(self, gate, control_qubit, target_qubit):
""" Adding a two qubit gate to the quantum circuit """
gate = str(gate).lower()
if not self.qc_initialised:
print("Initialise quantum circuit first.")
return
try:
control_qubit = self.q[control_qubit]
target_qubit = self.q[target_qubit]
except:
print("Initialising control and target qubits failed")
return
if gate == 'h' or gate == 'ch' or gate == 'control hadamard':
self.qc.h(control_qubit, target_qubit)
elif gate == 'x' or gate == 'cx' or gate == 'control x':
self.qc.cx(control_qubit, target_qubit)
elif gate == 'y' or gate == 'cy' or gate == 'control y':
self.qc.cy(control_qubit, target_qubit)
elif gate == 'z' or gate == 'cz' or gate == 'control z':
self.qc.cz(control_qubit, target_qubit)
else:
print("Not a valid two qubit gate. Gate not added to the circuit.")
def controlled_gate(self,
gate,
target_qubit,
control_bit,
control_value=1):
""" Adding a two qubit gate to the quantum circuit """
gate = str(gate).lower()
if not self.qc_initialised:
print("Initialise quantum circuit first.")
return
try:
control = self.c[control_bit]
qubit = self.q[target_qubit]
except:
print("Initialising control and target qubits failed")
return
if gate == 'h' or gate == 'ch' or gate == 'control hadamard':
self.qc.h(qubit).c_if(control[0], control_value)
elif gate == 'x' or gate == 'cx' or gate == 'control x':
self.qc.x(qubit).c_if(control, control_value)
elif gate == 'y' or gate == 'cy' or gate == 'control y':
self.qc.y(qubit).c_if(control[0], control_value)
elif gate == 'z' or gate == 'cz' or gate == 'control z':
self.qc.z(qubit).c_if(control, control_value)
else:
print("Not a valid two qubit gate. Gate not added to the circuit.")
def measure_gate(self, qubits=None, classical_bits=None):
""" Add a measure gate to the quantum circuit of the Experiment class.
If you give a list of qubits, then give a list of controls where the
index matches where the qubit measurement is stored.
"""
if not qubits and not classical_bits:
for i in self.c:
self.qc.measure(self.q[i], i)
elif qubits:
for index, q in enumerate(qubits):
self.qc.measure(self.q[q], self.c[classical_bits[index]][0])
print("measured q: {}, c: {}".format(
self.q[q], self.c[classical_bits[index]]))
def compile_and_run(self):
""" Compile the quantum code and run on the selected backend. """
if self.register_initialised and self.qc_initialised:
print("Running on backend: {}".format(self.backend))
if self.coupling_map:
print("Using coupling map for {}...".format(self.backend))
job = execute(self.qc,
backend=self.backend,
coupling_map=self.coupling_map,
shots=self.shots)
else:
job = execute(self.qc, backend=self.backend, shots=self.shots)
result = job.result()
self.data = result.get_counts(self.qc)
self.results = True
#print(result.get_data())
#print(inspect.getmembers(result, predicate=inspect.ismethod))
#print(result.get_ran_qasm(self.qc))
print("Status: {} \nMeasurement result: {}".format(
result, self.data))
else:
print("Initialise register and quantum circuit first.")
def get_data(self):
""" Return the result of the experiment in the form of a dictionary
with all combinations of measurements and the counts.
"""
if self.results:
return self.data
else:
print("Compile and run the experiment first!")
@staticmethod
def IBMQ_register():
try:
register(Qconfig.APItoken, Qconfig.config['url'])
print("Successfully connected to IBMQ.")
except ConnectionError as e:
print(
"{}\n\nFailed to connect to IBMQ - only local simulations are possible."
.format(e))
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add(f_in)
grover.add(f_out)
grover.add(aux)
grover.add(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_average(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
