def test_sympy(self):
desired_vector = [
0,
math.cos(math.pi / 3) * complex(0, 1) / math.sqrt(4),
math.sin(math.pi / 3) / math.sqrt(4),
0,
0,
0,
0,
0,
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(8) * complex(0, 1),
0,
0,
0,
0,
1 / math.sqrt(4),
1 / math.sqrt(4) * complex(0, 1)]
qp = QuantumProgram()
qr = QuantumRegister(4, "qr")
qc = QuantumCircuit(qr)
qc.initialize(desired_vector, [qr[0], qr[1], qr[2], qr[3]])
qp.add_circuit("qc", qc)
result = qp.execute("qc", backend='local_statevector_simulator')
statevector = result.get_statevector()
fidelity = state_fidelity(statevector, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def eval_cost_function_with_unlabeled_data(entangler_map, coupling_map,
initial_layout, n, m,
unlabeled_data, class_labels,
backend, shots, seed, train, theta):
predicted_results = []
Q_program = QuantumProgram()
circuits = []
for c_id, inpt in enumerate(unlabeled_data):
circuit_name, sequences = trial_circuit_ML(entangler_map, coupling_map,
initial_layout, n, m, theta,
inpt, '' + str(c_id), None,
True)
circuits.append(('', circuit_name))
Q_program.add_circuit(circuit_name, sequences)
circuit_list = [c[1] for c in circuits]
program_data = Q_program.execute(circuit_list,
backend=backend,
coupling_map=coupling_map,
initial_layout=initial_layout,
shots=shots,
seed=seed)
for v in range(len(circuit_list)):
countsloop = program_data.get_counts(circuit_list[v])
probs = return_probabilities(countsloop, class_labels)
predicted_results.append(
max(probs.items(), key=operator.itemgetter(1))[0])
return predicted_results
def test_add_circuit(self):
"""Test add two circuits.
If all correct should return the data
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 2, verbose=False)
cr = QP_program.create_classical_register("cr", 2, verbose=False)
qc1 = QP_program.create_circuit("qc1", [qr], [cr])
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
QP_program.set_api(API_TOKEN, URL)
qc1.h(qr[0])
qc1.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
new_circuit = qc1 + qc2
QP_program.add_circuit('new_circuit', new_circuit)
# new_circuit.measure(qr[0], cr[0])
circuits = ['new_circuit']
backend = 'local_qasm_simulator' # the backend to run on
shots = 1024 # the number of shots in the experiment.
result = QP_program.execute(circuits,
backend=backend,
shots=shots,
seed=78)
self.assertEqual(result.get_counts('new_circuit'), {
'00': 505,
'01': 519
})
def test_initialize_middle_circuit(self):
desired_vector = [0.5, 0.5, 0.5, 0.5]
qp = QuantumProgram()
qr = QuantumRegister("qr", 2)
cr = ClassicalRegister("cr", 2)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.reset(qr[0])
qc.reset(qr[1])
qc.initialize(desired_vector, [qr[0], qr[1]])
qc.measure(qr, cr)
qp.add_circuit("qc", qc)
# statevector simulator does not support reset
shots = 2000
threshold = 0.025 * shots
result = qp.execute("qc", backend='local_qasm_simulator', shots=shots)
counts = result.get_counts()
target = {
'00': shots / 4,
'01': shots / 4,
'10': shots / 4,
'11': shots / 4
}
self.assertDictAlmostEqual(counts, target, threshold)
def build_model_circuits(name, n):
qp = QuantumProgram()
q = qp.create_quantum_register("q", n)
c = qp.create_classical_register("c", n)
qft(qftcirc, q, n)
for j in range(n):
qp.add_circuit("%s_%d" % (name, n), qftcirc)
return qp
def main():
parser = argparse.ArgumentParser(description="Create circuits \
of Quantum Fourier \
Transform for \
quantum volume analysis.")
parser.add_argument('--name', default='qft', help='circuit name')
parser.add_argument('-n', '--qubits', default=5,
type=int, help='number of circuit qubits')
args = parser.parse_args()
qp = build_model_circuits(name=args.name, n=args.qubits)
circuit_name = args.name+'_n'+str(args.qubits)
f = open(circuit_name+'.qasm', 'w')
f.write(qp.get_qasm(name="%s_%d" % (args.name, args.qubits)))
f.close()
if __name__ == "__main__":
main()
def test_single_qubit(self):
desired_vector = [1 / math.sqrt(3), math.sqrt(2) / math.sqrt(3)]
qp = QuantumProgram()
qr = QuantumRegister("qr", 1)
qc = QuantumCircuit(qr)
qc.initialize(desired_vector, [qr[0]])
qp.add_circuit("qc", qc)
result = qp.execute("qc", backend='local_statevector_simulator')
statevector = result.get_statevector()
fidelity = state_fidelity(statevector, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_deterministic_state(self):
desired_vector = [0, 1, 0, 0]
qp = QuantumProgram()
qr = QuantumRegister("qr", 2)
qc = QuantumCircuit(qr)
qc.initialize(desired_vector, [qr[0], qr[1]])
qp.add_circuit("qc", qc)
result = qp.execute("qc", backend='local_statevector_simulator')
statevector = result.get_statevector()
fidelity = state_fidelity(statevector, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def build_model_circuits(name, n, depth, num_circ=1):
"""Create a quantum program containing model circuits.
The model circuits consist of layers of Haar random
elements of SU(4) applied between corresponding pairs
of qubits in a random bipartition.
name = leading name of circuits
n = number of qubits
depth = ideal depth of each model circuit (over SU(4))
num_circ = number of model circuits to construct
Return a quantum program.
"""
qp = QuantumProgram()
q = qp.create_quantum_register("q", n)
c = qp.create_classical_register("c", n)
# Create measurement subcircuit
meas = qp.create_circuit("meas", [q], [c])
for j in range(n):
meas.measure(q[j], c[j])
# For each sample number, build the model circuits
for i in range(num_circ):
# Initialize empty circuit Ci without measurement
circuit_i = qp.create_circuit("%s_%d" % (name, i), [q], [c])
# For each layer
for j in range(depth):
# Generate uniformly random permutation Pj of [0...n-1]
perm = np.random.permutation(n)
# For each pair p in Pj, generate Haar random SU(4)
# Decompose each SU(4) into CNOT + SU(2) and add to Ci
for k in range(math.floor(n / 2)):
qubits = [int(perm[2 * k]), int(perm[2 * k + 1])]
SU = random_SU(4)
for gate in two_qubit_kak(SU):
i0 = qubits[gate["args"][0]]
if gate["name"] == "cx":
i1 = qubits[gate["args"][1]]
circuit_i.cx(q[i0], q[i1])
elif gate["name"] == "u1":
circuit_i.u1(gate["params"][2], q[i0])
elif gate["name"] == "u2":
circuit_i.u2(gate["params"][1], gate["params"][2],
q[i0])
elif gate["name"] == "u3":
circuit_i.u3(gate["params"][0], gate["params"][1],
gate["params"][2], q[i0])
elif gate["name"] == "id":
pass # do nothing
# circuit_i.barrier(q) # barriers between layers
circuit_i.barrier(q) # barrier before measurement
# Create circuit with final measurement
qp.add_circuit("%s_%d_meas" % (name, i), circuit_i + meas)
return qp
def test_gate_x(self):
shots = 100
qp = QuantumProgram()
qr = QuantumRegister(1, "qr")
cr = ClassicalRegister(1, "cr")
qc = QuantumCircuit(qr, cr)
qc.x(qr[0])
qc.measure(qr, cr)
qp.add_circuit("circuit_name", qc)
result_pq = qp.execute('circuit_name',
backend='local_qasm_simulator_projectq',
seed=1,
shots=shots)
self.assertEqual(result_pq.get_counts(), {'1': shots})
def build_model_circuits(name, n):
qp = QuantumProgram()
q = qp.create_quantum_register("q", n)
c = qp.create_classical_register("c", n)
qftcirc = qp.create_circuit("meas", [q], [c])
qft(qftcirc, q, n)
qftcirc.barrier(q)
for j in range(n):
qftcirc.measure(q[j], c[j])
qp.add_circuit("%s_%d" % (name, n), qftcirc)
return qp
def test_random_3qubit(self):
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1), 0, 0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0), 0
]
qp = QuantumProgram()
qr = QuantumRegister("qr", 3)
qc = QuantumCircuit(qr)
qc.initialize(desired_vector, [qr[0], qr[1], qr[2]])
qp.add_circuit("qc", qc)
result = qp.execute("qc", backend='local_statevector_simulator')
statevector = result.get_statevector()
fidelity = state_fidelity(statevector, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_add_circuit_noname(self):
"""Test add two circuits without names. Also tests get_counts without circuit name.
"""
q_program = QuantumProgram()
qr = q_program.create_quantum_register(size=2)
cr = q_program.create_classical_register(size=2)
qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc1.h(qr[0])
qc1.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
new_circuit = qc1 + qc2
q_program.add_circuit(quantum_circuit=new_circuit)
backend = 'local_qasm_simulator_py' # cpp simulator rejects non string IDs (FIXME)
shots = 1024
result = q_program.execute(backend=backend, shots=shots, seed=78)
counts = result.get_counts(new_circuit.name)
target = {'00': shots / 2, '01': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
self.assertRaises(QISKitError, result.get_counts)
def test_add_circuit_noname(self):
"""Test add two circuits without names. Also tests get_counts without circuit name.
"""
q_program = QuantumProgram()
qr = q_program.create_quantum_register(size=2)
cr = q_program.create_classical_register(size=2)
qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc1.h(qr[0])
qc1.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
new_circuit = qc1 + qc2
q_program.add_circuit(quantum_circuit=new_circuit)
backend = 'local_qasm_simulator_py' # cpp simulator rejects non string IDs (FIXME)
shots = 1024
result = q_program.execute(backend=backend, shots=shots, seed=78)
counts = result.get_counts(new_circuit.name)
target = {'00': shots / 2, '01': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
self.assertRaises(QISKitError, result.get_counts)
def test_add_circuit(self):
QP_program = QuantumProgram(specs=QPS_SPECS)
qc, qr, cr = QP_program.get_quantum_elements()
qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"])
qc2.h(qr[0])
qc3.h(qr[1])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
new_circuit = qc2 + qc3
QP_program.add_circuit('new_circuit', new_circuit)
# new_circuit.measure(qr[0], cr[0])
circuits = ['new_circuit']
device = 'local_qasm_simulator' # the device to run on
shots = 1 # the number of shots in the experiment.
credits = 3
coupling_map = None
result = QP_program.execute(circuits, device, shots)
self.assertEqual(result['status'], 'COMPLETED')
def test_add_circuit(self):
"""Test add two circuits.
If all correct should return the data
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 2, verbose=False)
cr = QP_program.create_classical_register("cr", 2, verbose=False)
qc1 = QP_program.create_circuit("qc1", [qr], [cr])
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
QP_program.set_api(API_TOKEN, URL)
qc1.h(qr[0])
qc1.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
new_circuit = qc1 + qc2
QP_program.add_circuit('new_circuit', new_circuit)
# new_circuit.measure(qr[0], cr[0])
circuits = ['new_circuit']
backend = 'local_qasm_simulator' # the backend to run on
shots = 1024 # the number of shots in the experiment.
result = QP_program.execute(circuits, backend=backend, shots=shots,
seed=78)
self.assertEqual(result.get_counts('new_circuit'),
{'00': 505, '01': 519})
theCircuit.cx(qr[3], qr[2])
theCircuit.x(qr[3])
theCircuit.h(qr[3])
#measure the third and fourth qubits in the computational basis
theCircuit.measure(qr[2], cr[2])
theCircuit.measure(qr[3], cr[3])
a, b = random.randint(1, 3), random.randint(1, 3) #generate random integers
print("The values of a and b are, resp.,", a, b)
aliceCircuit = aliceCircuits["Alice" + str(a)]
bobCircuit = bobCircuits["Bob" + str(b)]
circuitName = "Alice" + str(a) + "Bob" + str(b)
Q_program.add_circuit(circuitName, sharedEntangled + aliceCircuit + bobCircuit)
backend = "local_qasm_simulator"
##backend = "ibmqx2"
shots = 1 # We perform a one-shot experiment
results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)
print(answer)
for key in answer.keys():
aliceAnswer = [int(key[-1]), int(key[-2])]
bobAnswer = [int(key[-3]), int(key[-4])]
if sum(aliceAnswer) % 2 == 0: #the sume of Alice answer must be even
aliceAnswer.append(0)
else:
aliceAnswer.append(1)
bv.x(tmp[0])
bv.h(q)
bv.h(tmp)
bv += oracle
bv.h(q)
bv.h(tmp)
bv.measure(q, res)
print(bv.qasm())
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(bv)
from qiskit import QuantumProgram
qp = QuantumProgram()
qp.add_circuit(quantum_circuit=bv, name='bv')
from qiskit import backends
print(backends.local_backends())
print(backends.remote_backends())
import Qconfig
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
result = qp.execute('bv', backend='ibmqx4', timeout=3600)
counts = result.get_counts('bv')
print(counts)
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
# CX from qubit 1 to qubit 0
qc.cx(q[2], q[1])
# Post circuit operations
qc.measure(q, c)
# See a list of available local simulators
print("Local backends: ", available_backends({'local': True}))
# Compile and run the Quantum circuit on a simulator backend
job_sim = execute(qc, "local_qasm_simulator", shots=10)
sim_result = job_sim.result()
# Create a quantum program for the process tomography simulation
processprogram = QuantumProgram()
processprogram.add_circuit('FTSWAP', qc)
# Create registers for the process tomography
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
# Create the tomography set
tomo_set = tomo.process_tomography_set([1, 0], 'Pauli', 'Pauli')
tomo_circuits = tomo.create_tomography_circuits(processprogram, 'FTSWAP',
qr, cr, tomo_set)
# Use the local simulator# Use t
backend = 'local_qasm_simulator'
# Take 5000 shots for each measurement basis
shots = 500
def eval_cost_function(entangler_map, coupling_map, initial_layout, n, m,
x_vec, class_labels, backend, shots, seed, train,
theta):
sample_shots = 0
# x_vec is the vector of training characteristics - size n
# y is the binary outcome for each x_vec
number_of_classes = len(class_labels)
cost = 0
total_cost = 0
std_cost = 0
predicted_results = []
Q_program = QuantumProgram()
# Q_program.set_api(Qconfig.APItoken,Qconfig.config["url"])
### RUN CIRCUITS
circuits = []
c = []
sequences = []
unlabeled_data = []
for arrays in range(number_of_classes):
labelgroup = x_vec[class_labels[arrays]]
for item in labelgroup:
unlabeled_data.append(item)
# unlabeled_data = np.array([])
# for arrays in range(number_of_classes):
# unlabeled_data = np.vstack((unlabeled_data,x_vec[class_labels[arrays]])) if unlabeled_data.size else x_vec[class_labels[arrays]]
for key in x_vec.keys():
for c_id, inpt in enumerate(x_vec[key]):
c, sequences = trial_circuit_ML(entangler_map, coupling_map,
initial_layout, n, m, theta, inpt,
key + str(c_id), None, True)
# c is 'A0', 'A1', 'A2', etc...
circuits.append((key, c))
Q_program.add_circuit(c, sequences)
circuit_list = [c[1] for c in circuits]
# circuits is ['A', 'A0'], ['A', 'A1'], ..., ['B', 'B0'],... etc
# print(Q_program.get_qasm(circuit_list[0]))
program_data = Q_program.execute(circuit_list,
backend=backend,
coupling_map=coupling_map,
initial_layout=initial_layout,
shots=shots,
seed=seed)
result = 0
success = 0
for v in range(len(circuit_list)):
countsloop = program_data.get_counts(circuit_list[v])
for cl in range(number_of_classes):
if circuits[v][0] == class_labels[cl]:
expected_outcome = class_labels[cl]
probs = return_probabilities(countsloop, class_labels)
result += cost_estimate_sigmoid(200, probs, expected_outcome)
predicted_results.append(
max(probs.items(), key=operator.itemgetter(1))[0])
if max(probs.items(),
key=operator.itemgetter(1))[0] == expected_outcome:
success += 1
global print_info
if not train and print_info:
print("\n=============================================\n")
print('Classifying point %s. Label should be %s \n' %
(unlabeled_data[v], expected_outcome))
print('Measured label probability distribution is %s \n' % probs)
if max(probs.items(),
key=operator.itemgetter(1))[0] == expected_outcome:
print('Assigned label is %s CORRECT \n' %
max(probs.items(), key=operator.itemgetter(1))[0])
else:
print('Assigned label is %s INCORRECT \n' %
max(probs.items(), key=operator.itemgetter(1))[0])
total_cost = result / len(circuit_list)
success_ratio = success / len(circuit_list)
return total_cost, std_cost, success_ratio, predicted_results
#print(qiskit.available_backends())
job = qiskit.execute(bell, backend='local_statevector_simulator')
bell_psi = job.result().get_statevector(bell)
bell_rho = outer(
bell_psi) # construct the density matrix from the state vector
#plot the state
plot_state(bell_rho, 'paulivec')
# Construct state tomography set for measurement of qubits [0, 1] in the Pauli basis
bell_tomo_set = tomo.state_tomography_set([0, 1])
# Create a quantum program containing the state preparation circuit
Q_program = QuantumProgram()
Q_program.add_circuit('bell', bell)
# Add the state tomography measurement circuits to the Quantum Program
bell_tomo_circuit_names = tomo.create_tomography_circuits(
Q_program, 'bell', qr, cr, bell_tomo_set)
print('Created State tomography circuits:')
for name in bell_tomo_circuit_names:
print(name)
# Use the local simulator# Use t
backend = 'local_qasm_simulator'
# Take 5000 shots for each measurement basis
shots = 5000
observable_second_ideal = {'00': 1, '01': 1, '10': -1, '11': -1}
observable_correlated_ideal = {'00': 1, '01': -1, '10': -1, '11': 1}
program = []
xdata = []
program_end = [measureZZ, measureZX, measureXX, measureXZ]
k = 0
for jj in range(30):
theta = 2.0 * np.pi * jj / 30
bell_middle = QuantumCircuit(q, c)
bell_middle.ry(theta, q[0])
for i in range(4):
program.append('circuit' + str(k))
Q_program.add_circuit('circuit' + str(k),
bell + bell_middle + program_end[i])
k += 1
xdata.append(theta)
Q_program.get_qasms(program[0:8])
result = Q_program.execute(program,
backend=backend,
shots=shots,
max_credits=3,
wait=10,
timeout=240,
silent=False)
CHSH_data_sim = []
measureYXY.measure(q3[0], c3[0])
measureYXY.measure(q3[1], c3[1])
measureYXY.measure(q3[2], c3[2])
# quantum circuit to measure q YYX
measureYYX = Q_program.create_circuit('measureYYX', [q3], [c3])
measureYYX.s(q3[0]).inverse()
measureYYX.s(q3[1]).inverse()
measureYYX.h(q3[0])
measureYYX.h(q3[1])
measureYYX.h(q3[2])
measureYYX.measure(q3[0], c3[0])
measureYYX.measure(q3[1], c3[1])
measureYYX.measure(q3[2], c3[2])
Q_program.add_circuit('ghz_measureXXX', ghz + measureXXX)
Q_program.add_circuit('ghz_measureYYX', ghz + measureYYX)
Q_program.add_circuit('ghz_measureYXY', ghz + measureYXY)
Q_program.add_circuit('ghz_measureXYY', ghz + measureXYY)
circuits = [
'ghz_measureXXX', 'ghz_measureYYX', 'ghz_measureYXY', 'ghz_measureXYY'
]
Q_program.get_qasms(circuits)
result6 = Q_program.execute(circuits,
backend=backend,
shots=shots,
max_credits=5,
wait=10,
timeout=240,
silent=False)
circuitName = "Decode" + pos
decodingCircuits[circuitName] = program.create_circuit(
circuitName, [q_register], [c_register])
if pos == "Second": #if pos == "First" we can directly measure
decodingCircuits[circuitName].h(q_register[0])
elif pos == "Third":
decodingCircuits[circuitName].u3(pi / 2, -pi / 2, pi / 2,
q_register[0])
decodingCircuits[circuitName].measure(q_register[0], c_register[0])
#combine encoding and decoding of q_registerACs to get a list of complete circuits
circuitNames = []
for k1 in encodingCircuits.keys():
for k2 in decodingCircuits.keys():
circuitNames.append(k1 + k2)
program.add_circuit(k1 + k2,
encodingCircuits[k1] + decodingCircuits[k2])
print("List of circuit names:", circuitNames) #list of circuit names
#program.get_qasms(circuitNames) #list qasms codes
results = program.execute(circuitNames, backend=backend, shots=shots)
print("Experimental Result of Encode010DecodeFirst")
plot_histogram_file(
"Encode010DecodeFirst.svg", results.get_counts(
"Encode010DecodeFirst")) #We should measure "0" with probability 0.78
print("Experimental Result of Encode010DecodeSecond")
plot_histogram_file(
"Encode010DecodeSecond.svg", results.get_counts(
"Encode010DecodeSecond")) #We should measure "1" with probability 0.78
print("Experimental Result of Encode010DecodeThird")
plot_histogram_file(
measureXX.measure(q[0], c[0])
measureXX.measure(q[1], c[1])
# quantum circuit to measure ZX
measureZX = program.create_circuit('measureZX', [q], [c])
measureZX.h(q[0])
measureZX.measure(q[0], c[0])
measureZX.measure(q[1], c[1])
# quantum circuit to measure XZ
measureXZ = program.create_circuit('measureXZ', [q], [c])
measureXZ.h(q[1])
measureXZ.measure(q[0], c[0])
measureXZ.measure(q[1], c[1])
program.add_circuit('bell_measureZX', bell + measureZX)
program.add_circuit('bell_measureXZ', bell + measureXZ)
program.add_circuit('bell_measureZZ', bell + measureZZ)
program.add_circuit('bell_measureXX', bell + measureXX)
circuits = [
'bell_measureZZ', 'bell_measureZX', 'bell_measureXX', 'bell_measureXZ'
]
program.get_qasms(circuits)
result = program.execute(circuits,
backend=backend,
shots=shots,
max_credits=3,
wait=10,
timeout=240,
class QC():
'''
class QC
'''
# pylint: disable=too-many-instance-attributes
def __init__(self, backend='local_qasm_simulator', remote=False, qubits=3):
# private member
# __qp
self.__qp = None
# calc phase
self.phase = [
['0', 'initialized.']
]
# config
self.backend = backend
self.remote = remote
self.qubits = qubits
# circuits variable
self.shots = 2
# async
self.wait = False
self.last = ['init', 'None']
self.load()
def load(self, api_info=True):
'''
load
'''
self.__qp = QuantumProgram()
if self.remote:
try:
import Qconfig
self.__qp.set_api(Qconfig.APItoken, Qconfig.config["url"],
hub=Qconfig.config["hub"],
group=Qconfig.config["group"],
project=Qconfig.config["project"])
except ImportError as ex:
msg = 'Error in loading Qconfig.py!. Error = {}\n'.format(ex)
sys.stdout.write(msg)
sys.stdout.flush()
return False
if api_info is True:
api = self.__qp.get_api()
sys.stdout.write('<IBM Quantum Experience API information>\n')
sys.stdout.flush()
sys.stdout.write('Version: {0}\n'.format(api.api_version()))
sys.stdout.write('User jobs (last 5):\n')
jobs = api.get_jobs(limit=500)
def format_date(job_item):
'''
format
'''
return datetime.strptime(job_item['creationDate'],
'%Y-%m-%dT%H:%M:%S.%fZ')
sortedjobs = sorted(jobs,
key=format_date)
sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n'
.format('id',
'creationDate',
'status',
'backend'))
sys.stdout.write('{:-^94}\n'.format(""))
for job in sortedjobs[-5:]:
sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n'
.format(job['id'],
job['creationDate'],
job['status'],
job['backend']['name']))
sys.stdout.write('There are {0} jobs on the server\n'
.format(len(jobs)))
sys.stdout.write('Credits: {0}\n'
.format(api.get_my_credits()))
sys.stdout.flush()
self.backends = self.__qp.available_backends()
status = self.__qp.get_backend_status(self.backend)
if 'available' in status:
if status['available'] is False:
return False
return True
def set_config(self, config=None):
'''
set config
'''
if config is None:
config = {}
if 'backend' in config:
self.backend = str(config['backend'])
if 'local_' in self.backend:
self.remote = False
else:
self.remote = True
if 'remote' in config:
self.remote = config['remote']
if 'qubits' in config:
self.qubits = int(config['qubits'])
return True
def _progress(self, phasename, text):
self.phase.append([str(phasename), str(text)])
text = "Phase {0}: {1}".format(phasename, text)
sys.stdout.write("{}\n".format(text))
sys.stdout.flush()
def _init_circuit(self):
self._progress('1', 'Initialize quantum registers and circuit')
qubits = self.qubits
quantum_registers = [
{"name": "cin", "size": 1},
{"name": "qa", "size": qubits},
{"name": "qb", "size": qubits},
{"name": "cout", "size": 1}
]
classical_registers = [
{"name": "ans", "size": qubits + 1}
]
if 'cin' in self.__qp.get_quantum_register_names():
self.__qp.destroy_quantum_registers(quantum_registers)
self.__qp.destroy_classical_registers(classical_registers)
q_r = self.__qp.create_quantum_registers(quantum_registers)
c_r = self.__qp.create_classical_registers(classical_registers)
self.__qp.create_circuit("qcirc", q_r, c_r)
def _create_circuit_qadd(self):
# quantum ripple-carry adder from Cuccaro et al, quant-ph/0410184
def majority(circuit, q_a, q_b, q_c):
'''
majority
'''
circuit.cx(q_c, q_b)
circuit.cx(q_c, q_a)
circuit.ccx(q_a, q_b, q_c)
def unmaj(circuit, q_a, q_b, q_c):
'''
unmajority
'''
circuit.ccx(q_a, q_b, q_c)
circuit.cx(q_c, q_a)
circuit.cx(q_a, q_b)
def adder(circuit, c_in, q_a, q_b, c_out, qubits):
'''
adder
'''
# pylint: disable=too-many-arguments
majority(circuit, c_in[0], q_b[0], q_a[0])
for i in range(qubits - 1):
majority(circuit, q_a[i], q_b[i + 1], q_a[i + 1])
circuit.cx(q_a[qubits - 1], c_out[0])
for i in range(qubits - 1)[::-1]:
unmaj(circuit, q_a[i], q_b[i + 1], q_a[i + 1])
unmaj(circuit, c_in[0], q_b[0], q_a[0])
if 'add' not in self.__qp.get_circuit_names():
[c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register,
["cin", "qa", "qb", "cout"])
ans = self.__qp.get_classical_register('ans')
qadder = self.__qp.create_circuit("qadd",
[c_in, q_a, q_b, c_out],
[ans])
adder(qadder, c_in, q_a, q_b, c_out, self.qubits)
return 'add' in self.__qp.get_circuit_names()
def _create_circuit_qsub(self):
circuit_names = self.__qp.get_circuit_names()
if 'qsub' not in circuit_names:
if 'qadd' not in circuit_names:
self._create_circuit_qadd()
# subtractor circuit
self.__qp.add_circuit('qsub', self.__qp.get_circuit('qadd'))
qsubtractor = self.__qp.get_circuit('qsub')
qsubtractor.reverse()
return 'qsub' in self.__qp.get_circuit_names()
def _qadd(self, input_a, input_b=None, subtract=False, observe=False):
# pylint: disable=too-many-locals
def measure(circuit, q_b, c_out, ans):
'''
measure
'''
circuit.barrier()
for i in range(self.qubits):
circuit.measure(q_b[i], ans[i])
circuit.measure(c_out[0], ans[self.qubits])
def char2q(circuit, cbit, qbit):
'''
char2q
'''
if cbit == '1':
circuit.x(qbit)
elif cbit == 'H':
circuit.h(qbit)
self.shots = 5 * (2**self.qubits)
def input_state(circuit, input_a, input_b=None):
'''
input state
'''
input_a = input_a[::-1]
for i in range(self.qubits):
char2q(circuit, input_a[i], q_a[i])
if input_b is not None:
input_b = input_b[::-1]
for i in range(self.qubits):
char2q(circuit, input_b[i], q_b[i])
def reset_input(circuit, c_in, q_a, c_out):
'''
reset input
'''
circuit.reset(c_in)
circuit.reset(c_out)
for i in range(self.qubits):
circuit.reset(q_a[i])
# get registers
[c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register,
["cin", "qa", "qb", "cout"])
ans = self.__qp.get_classical_register('ans')
qcirc = self.__qp.get_circuit('qcirc')
self._progress('2',
'Define input state ({})'
.format('QADD' if subtract is False else 'QSUB'))
if input_b is not None:
if subtract is True:
# subtract
input_state(qcirc, input_b, input_a)
else:
# add
input_state(qcirc, input_a, input_b)
else:
reset_input(qcirc, c_in, q_a, c_out)
input_state(qcirc, input_a)
self._progress('3',
'Define quantum circuit ({})'
.format('QADD' if subtract is False else 'QSUB'))
if subtract is True:
self._create_circuit_qsub()
qcirc.extend(self.__qp.get_circuit('qsub'))
else:
self._create_circuit_qadd()
qcirc.extend(self.__qp.get_circuit('qadd'))
if observe is True:
measure(qcirc, q_b, c_out, ans)
def _qsub(self, input_a, input_b=None, observe=False):
self._qadd(input_a, input_b, subtract=True, observe=observe)
def _qope(self, input_a, operator, input_b=None, observe=False):
if operator == '+':
return self._qadd(input_a, input_b, observe=observe)
elif operator == '-':
return self._qsub(input_a, input_b, observe=observe)
return None
def _compile(self, name, cross_backend=None, print_qasm=False):
self._progress('4', 'Compile quantum circuit')
coupling_map = None
if cross_backend is not None:
backend_conf = self.__qp.get_backend_configuration(cross_backend)
coupling_map = backend_conf.get('coupling_map', None)
if coupling_map is None:
sys.stdout.write('backend: {} coupling_map not found'
.format(cross_backend))
qobj = self.__qp.compile([name],
backend=self.backend,
shots=self.shots,
seed=1,
coupling_map=coupling_map)
if print_qasm is True:
sys.stdout.write(self.__qp.get_compiled_qasm(qobj, 'qcirc'))
sys.stdout.flush()
return qobj
def _run(self, qobj):
self._progress('5', 'Run quantum circuit (wait for answer)')
result = self.__qp.run(qobj, wait=5, timeout=100000)
return result
def _run_async(self, qobj):
'''
_run_async
'''
self._progress('5', 'Run quantum circuit')
self.wait = True
def async_result(result):
'''
async call back
'''
self.wait = False
self.last = self.result_parse(result)
self.__qp.run_async(qobj,
wait=5, timeout=100000, callback=async_result)
def _is_regular_number(self, numstring, base):
'''
returns input binary format string or None.
'''
if base == 'bin':
binstring = numstring
elif base == 'dec':
if numstring == 'H':
binstring = 'H'*self.qubits
else:
binstring = format(int(numstring), "0{}b".format(self.qubits))
if len(binstring) != self.qubits:
return None
return binstring
def get_seq(self, text, base='dec'):
'''
convert seq and check it
if text is invalid, return the list of length 0.
'''
operators = u'(\\+|\\-)'
seq = re.split(operators, text)
# length check
if len(seq) % 2 == 0 or len(seq) == 1:
return []
# regex
if base == 'bin':
regex = re.compile(r'[01H]+')
else:
regex = re.compile(r'(^(?!.H)[0-9]+|H)')
for i in range(0, len(seq), 2):
match = regex.match(seq[i])
if match is None:
return []
num = match.group(0)
seq[i] = self._is_regular_number(num, base)
if seq[i] is None:
return []
return seq
def result_parse(self, result):
'''
result_parse
'''
data = result.get_data("qcirc")
sys.stdout.write("job id: {0}\n".format(result.get_job_id()))
sys.stdout.write("raw result: {0}\n".format(data))
sys.stdout.write("{:=^40}\n".format("answer"))
counts = data['counts']
sortedcounts = sorted(counts.items(),
key=lambda x: -x[1])
sortedans = []
for count in sortedcounts:
if count[0][0] == '1':
ans = 'OR'
else:
ans = str(int(count[0][-self.qubits:], 2))
sortedans.append(ans)
sys.stdout.write('Dec: {0:>2} Bin: {1} Count: {2} \n'
.format(ans, str(count[0]), str(count[1])))
sys.stdout.write('{0:d} answer{1}\n'
.format(len(sortedans),
'' if len(sortedans) == 1 else 's'))
sys.stdout.write("{:=^40}\n".format(""))
if 'time' in data:
sys.stdout.write("time: {0:<3} sec\n".format(data['time']))
sys.stdout.write("All process done.\n")
sys.stdout.flush()
uniqanswer = sorted(set(sortedans), key=sortedans.index)
ans = ",".join(uniqanswer)
return [str(result), ans]
def exec_calc(self, text, base='dec', wait_result=False):
'''
exec_calc
'''
seq = self.get_seq(text, base)
print('QC seq:', seq)
if seq == []:
return ["Syntax error", None]
# fail message
fail_msg = None
try:
self._init_circuit()
numbers = seq[0::2] # slice even index
i = 1
observe = False
for oper in seq[1::2]: # slice odd index
if i == len(numbers) - 1:
observe = True
if i == 1:
self._qope(numbers[0], oper, numbers[1], observe=observe)
else:
self._qope(numbers[i], oper, observe=observe)
i = i + 1
qobj = self._compile('qcirc')
if wait_result is True:
[status, ans] = self.result_parse(self._run(qobj))
else:
self._run_async(qobj)
[status, ans] = [
'Wait. Calculating on {0}'.format(self.backend),
'...'
]
except QISKitError as ex:
fail_msg = ('There was an error in the circuit!. Error = {}\n'
.format(ex))
except RegisterSizeError as ex:
fail_msg = ('Error in the number of registers!. Error = {}\n'
.format(ex))
if fail_msg is not None:
sys.stdout.write(fail_msg)
sys.stdout.flush()
return ["FAIL", None]
return [status, ans]
initial_theta,SPSA_params,max_trials,save_step,1);
plt.plot(np.arange(0, max_trials,save_step), cost_plus,label='C(theta_plus)')
plt.plot(np.arange(0, max_trials,save_step),cost_minus,label='C(theta_minus)')
plt.plot(np.arange(0, max_trials,save_step),np.ones(max_trials//save_step)*best_distance_quantum, label='Final Optimized Cost')
plt.plot(np.arange(0, max_trials,save_step),np.ones(max_trials//save_step)*exact, label='Exact Cost')
plt.legend()
plt.xlabel('Number of trials')
plt.ylabel('Cost')
shots = 5000
circuits = ['final_circuit']
Q_program.add_circuit('final_circuit', trial_circuit_ry(n, m, best_theta, entangler_map, None, True))
result = Q_program.execute(circuits, backend=backend, shots=shots, coupling_map=coupling_map, initial_layout=initial_layout)
data = result.get_counts('final_circuit')
plot_histogram(data,5)
# Getting the solution and cost from the largest component of the optimal quantum state
max_value = max(data.values()) # maximum value
max_keys = [k for k, v in data.items() if v == max_value] # getting all keys containing the `maximum`
x_quantum=np.zeros(n)
for bit in range(n):
if max_keys[0][bit]=='1':
#backend = 'local_qasm_simulator' # the device to run on
backend = 'ibmqx2' # the backend to run on
shots = 1024 # the number of shots in the experiment
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
# quantum circuit to make GHZ state
q3 = Q_program.create_quantum_register('q3', 3)
c3 = Q_program.create_classical_register('c3', 3)
ghz = Q_program.create_circuit('ghz', [q3], [c3])
ghz.h(q3[0])
ghz.cx(q3[0], q3[1])
ghz.cx(q3[0], q3[2])
# quantum circuit to measure q in standard basis
measureZZZ = Q_program.create_circuit('measureZZZ', [q3], [c3])
measureZZZ.measure(q3[0], c3[0])
measureZZZ.measure(q3[1], c3[1])
measureZZZ.measure(q3[2], c3[2])
Q_program.add_circuit('ghz_measureZZZ', ghz + measureZZZ)
circuits = ['ghz_measureZZZ']
Q_program.get_qasms(circuits)
result5 = Q_program.execute(circuits,
backend=backend,
shots=shots,
max_credits=5,
wait=10,
timeout=240,
silent=True)
plot_histogram_file('ghz_measureZZZ.svg', result5.get_counts('ghz_measureZZZ'))
p_flip.iden(q3[0])
p_flip.iden(q3[1])
p_flip.iden(q3[2])
p_flip.z(q3[0])
p_flip.h(q3[0])
p_flip.h(q3[1])
p_flip.h(q3[2])
p_flip.cx(q3[0], q3[2])
p_flip.cx(q3[0], q3[1])
p_flip.ccx(q3[2], q3[1], q3[0])
measureZ = QuantumCircuit(q3, c3)
measureZ.measure(q3[2], c3[2])
measureZ.measure(q3[1], c3[1])
measureZ.measure(q3[0], c3[0])
Q_program.add_circuit("p_flip_code", p_flip + measureZ)
circuits = ["p_flip_code"]
result = Q_program.execute(circuits,
backend=backend,
shots=shots,
max_credits=3,
wait=10,
timeout=600)
plot_histogram(result.get_counts("p_flip_code"))
print(result.get_counts("p_flip_code"))
def kernel_join(points_array, points_array2, entangler_map, coupling_map,
initial_layout, shots, seed, num_of_qubits, backend):
Q_program = QuantumProgram()
circuits = []
is_identical = np.all(points_array == points_array2)
my_zero_string = get_zero_string(num_of_qubits)
if is_identical: # we reduce the computation by leveraging the symmetry of matrix: compute only the upper-right corner
size = len(points_array)
my_product_list = list(
itertools.combinations(range(len(points_array)), 2))
for a in range(len(my_product_list)):
first_index = my_product_list[a][
0] # This number is first datapoint in product
second_index = my_product_list[a][
1] # This number is second datapoint in product
sequencesp = inner_prod_circuit_ML(entangler_map, coupling_map,
initial_layout, num_of_qubits,
points_array[first_index],
points_array[second_index],
None, True)
circuit_name = 'join_' + str(first_index) + "_" + str(second_index)
circuits.append(circuit_name)
Q_program.add_circuit(circuit_name, sequencesp)
circuit_list = [c for c in circuits]
program_data = Q_program.execute(circuit_list,
backend=backend,
coupling_map=coupling_map,
initial_layout=initial_layout,
shots=shots,
seed=seed)
mat = np.eye(
size,
size) # element on the diagonal is always 1: point*point=|point|^2
for v in range(len(program_data)):
circuit_name = circuits[v]
tmp = circuit_name.split('_')
first_index = int(tmp[1])
second_index = int(tmp[2])
countsloop = program_data.get_counts(circuit_list[v])
if my_zero_string in countsloop:
mat[first_index][
second_index] = countsloop[my_zero_string] / shots
else:
mat[first_index][second_index] = 0
mat[second_index][first_index] = mat[first_index][second_index]
return mat
else:
Q_program = QuantumProgram()
total_test = points_array
svm = points_array2
for a in range(len(total_test)):
for b in range(len(svm)):
sequencesp = inner_prod_circuit_ML(entangler_map, coupling_map,
initial_layout,
num_of_qubits, svm[b],
total_test[a], None, True)
cp = 'join_' + str(a) + "_" + str(b)
circuits.append(cp)
Q_program.add_circuit(cp, sequencesp)
circuit_list = [c for c in circuits]
program_data = Q_program.execute(circuit_list,
backend=backend,
coupling_map=coupling_map,
initial_layout=initial_layout,
shots=shots,
seed=seed)
mat = np.zeros((len(total_test), len(svm)))
for v in range(len(program_data)):
countsloop = program_data.get_counts(circuit_list[v])
if my_zero_string in countsloop:
circuit_name = circuits[v]
tmp = circuit_name.split('_')
first_index = int(tmp[1])
second_index = int(tmp[2])
countsloop = program_data.get_counts(circuit_list[v])
if my_zero_string in countsloop:
mat[first_index][
second_index] = countsloop[my_zero_string] / shots
else:
mat[first_index][second_index] = 0
return mat
def msquare():
ans = []
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken,
Qconfig.config["url"]) # set the APIToken and API url
N = 4
# Creating registers
qr = Q_program.create_quantum_register("qr", N)
# for recording the measurement on qr
cr = Q_program.create_classical_register("cr", N)
circuitName = "sharedEntangled"
sharedEntangled = Q_program.create_circuit(circuitName, [qr], [cr])
#Create uniform superposition of all strings of length 2
for i in range(2):
sharedEntangled.h(qr[i])
#The amplitude is minus if there are odd number of 1s
for i in range(2):
sharedEntangled.z(qr[i])
#Copy the content of the fist two qubits to the last two qubits
for i in range(2):
sharedEntangled.cx(qr[i], qr[i + 2])
#Flip the last two qubits
for i in range(2, 4):
sharedEntangled.x(qr[i])
#we first define controlled-u gates required to assign phases
from math import pi
def ch(qProg, a, b):
""" Controlled-Hadamard gate """
qProg.h(b)
qProg.sdg(b)
qProg.cx(a, b)
qProg.h(b)
qProg.t(b)
qProg.cx(a, b)
qProg.t(b)
qProg.h(b)
qProg.s(b)
qProg.x(b)
qProg.s(a)
return qProg
def cu1pi2(qProg, c, t):
""" Controlled-u1(phi/2) gate """
qProg.u1(pi / 4.0, c)
qProg.cx(c, t)
qProg.u1(-pi / 4.0, t)
qProg.cx(c, t)
qProg.u1(pi / 4.0, t)
return qProg
def cu3pi2(qProg, c, t):
""" Controlled-u3(pi/2, -pi/2, pi/2) gate """
qProg.u1(pi / 2.0, t)
qProg.cx(c, t)
qProg.u3(-pi / 4.0, 0, 0, t)
qProg.cx(c, t)
qProg.u3(pi / 4.0, -pi / 2.0, 0, t)
return qProg
# dictionary for Alice's operations/circuits
aliceCircuits = {}
# Quantum circuits for Alice when receiving idx in 1, 2, 3
for idx in range(1, 4):
circuitName = "Alice" + str(idx)
aliceCircuits[circuitName] = Q_program.create_circuit(
circuitName, [qr], [cr])
theCircuit = aliceCircuits[circuitName]
if idx == 1:
#the circuit of A_1
theCircuit.x(qr[1])
theCircuit.cx(qr[1], qr[0])
theCircuit = cu1pi2(theCircuit, qr[1], qr[0])
theCircuit.x(qr[0])
theCircuit.x(qr[1])
theCircuit = cu1pi2(theCircuit, qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit = cu1pi2(theCircuit, qr[0], qr[1])
theCircuit = cu3pi2(theCircuit, qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit = ch(theCircuit, qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit.x(qr[1])
theCircuit.cx(qr[1], qr[0])
theCircuit.x(qr[1])
elif idx == 2:
theCircuit.x(qr[0])
theCircuit.x(qr[1])
theCircuit = cu1pi2(theCircuit, qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit.x(qr[1])
theCircuit = cu1pi2(theCircuit, qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit.h(qr[0])
theCircuit.h(qr[1])
elif idx == 3:
theCircuit.cz(qr[0], qr[1])
theCircuit.swap(qr[0], qr[1])
theCircuit.h(qr[0])
theCircuit.h(qr[1])
theCircuit.x(qr[0])
theCircuit.x(qr[1])
theCircuit.cz(qr[0], qr[1])
theCircuit.x(qr[0])
theCircuit.x(qr[1])
#measure the first two qubits in the computational basis
theCircuit.measure(qr[0], cr[0])
theCircuit.measure(qr[1], cr[1])
# dictionary for Bob's operations/circuits
bobCircuits = {}
# Quantum circuits for Bob when receiving idx in 1, 2, 3
for idx in range(1, 4):
circuitName = "Bob" + str(idx)
bobCircuits[circuitName] = Q_program.create_circuit(
circuitName, [qr], [cr])
theCircuit = bobCircuits[circuitName]
if idx == 1:
theCircuit.x(qr[2])
theCircuit.x(qr[3])
theCircuit.cz(qr[2], qr[3])
theCircuit.x(qr[3])
theCircuit.u1(pi / 2.0, qr[2])
theCircuit.x(qr[2])
theCircuit.z(qr[2])
theCircuit.cx(qr[2], qr[3])
theCircuit.cx(qr[3], qr[2])
theCircuit.h(qr[2])
theCircuit.h(qr[3])
theCircuit.x(qr[3])
theCircuit = cu1pi2(theCircuit, qr[2], qr[3])
theCircuit.x(qr[2])
theCircuit.cz(qr[2], qr[3])
theCircuit.x(qr[2])
theCircuit.x(qr[3])
elif idx == 2:
theCircuit.x(qr[2])
theCircuit.x(qr[3])
theCircuit.cz(qr[2], qr[3])
theCircuit.x(qr[3])
theCircuit.u1(pi / 2.0, qr[3])
theCircuit.cx(qr[2], qr[3])
theCircuit.h(qr[2])
theCircuit.h(qr[3])
elif idx == 3:
theCircuit.cx(qr[3], qr[2])
theCircuit.x(qr[3])
theCircuit.h(qr[3])
#measure the third and fourth qubits in the computational basis
theCircuit.measure(qr[2], cr[2])
theCircuit.measure(qr[3], cr[3])
a, b = random.randint(1, 3), random.randint(1,
3) #generate random integers
for i in range(3):
for j in range(3):
a = i + 1
b = j + 1
# print("The values of a and b are, resp.,", a,b)
aliceCircuit = aliceCircuits["Alice" + str(a)]
bobCircuit = bobCircuits["Bob" + str(b)]
circuitName = "Alice" + str(a) + "Bob" + str(b)
Q_program.add_circuit(circuitName,
sharedEntangled + aliceCircuit + bobCircuit)
backend = "local_qasm_simulator"
##backend = "ibmqx2"
shots = 1 # We perform a one-shot experiment
results = Q_program.execute([circuitName],
backend=backend,
shots=shots)
answer = results.get_counts(circuitName)
# print(answer)
for key in answer.keys():
aliceAnswer = [int(key[-1]), int(key[-2])]
bobAnswer = [int(key[-3]), int(key[-4])]
if sum(aliceAnswer
) % 2 == 0: #the sume of Alice answer must be even
aliceAnswer.append(0)
else:
aliceAnswer.append(1)
if sum(bobAnswer) % 2 == 1: #the sum of Bob answer must be odd
bobAnswer.append(0)
else:
bobAnswer.append(1)
break
# print("Alice answer for a = ", a, "is", aliceAnswer)
# print("Bob answer for b = ", b, "is", bobAnswer)
print(a, b)
ans.append(aliceAnswer)
ans.append(bobAnswer)
# if(aliceAnswer[b-1] != bobAnswer[a-1]): #check if the intersection of their answers is the same
# print("Alice and Bob lost")
# else:
# print("Alice and Bob won")
backend = "local_qasm_simulator"
#backend = "ibmqx2"
shots = 10 # We perform 10 shots of experiments for each round
nWins = 0
nLost = 0
for a in range(1, 4):
for b in range(1, 4):
# print("Asking Alice and Bob with a and b are, resp.,", a,b)
rWins = 0
rLost = 0
aliceCircuit = aliceCircuits["Alice" + str(a)]
bobCircuit = bobCircuits["Bob" + str(b)]
circuitName = "Alice" + str(a) + "Bob" + str(b)
Q_program.add_circuit(
circuitName,
sharedEntangled + aliceCircuit + bobCircuit)
if backend == "ibmqx2":
ibmqx2_backend = Q_program.get_backend_configuration(
'ibmqx2')
ibmqx2_coupling = ibmqx2_backend['coupling_map']
results = Q_program.execute(
[circuitName],
backend=backend,
shots=shots,
coupling_map=ibmqx2_coupling,
max_credits=3,
wait=10,
timeout=240)
else:
results = Q_program.execute([circuitName],
backend=backend,
shots=shots)
answer = results.get_counts(circuitName)
for key in answer.keys():
kfreq = answer[
key] #frequencies of keys obtained from measurements
aliceAnswer = [int(key[-1]), int(key[-2])]
bobAnswer = [int(key[-3]), int(key[-4])]
if sum(aliceAnswer) % 2 == 0:
aliceAnswer.append(0)
else:
aliceAnswer.append(1)
if sum(bobAnswer) % 2 == 1:
bobAnswer.append(0)
else:
bobAnswer.append(1)
#print("Alice answer for a = ", a, "is", aliceAnswer)
#print("Bob answer for b = ", b, "is", bobAnswer)
if (aliceAnswer[b - 1] != bobAnswer[a - 1]):
#print(a, b, "Alice and Bob lost")
nLost += kfreq
rLost += kfreq
else:
#print(a, b, "Alice and Bob won")
nWins += kfreq
rWins += kfreq
# print("\t#wins = ", rWins, "out of ", shots, "shots")
#
# print("Number of Games = ", nWins+nLost)
# print("Number of Wins = ", nWins)
# print("Winning probabilities = ", (nWins*100.0)/(nWins+nLost))
return ans
measureXI.h(q_register[1])
measureXI.measure(q_register[1], c_register[1])
# quantum circuit to measure q in the standard basis
measureZZ = program.create_circuit("measureZZ", [q_register], [c_register])
measureZZ.measure(q_register[0], c_register[0])
measureZZ.measure(q_register[1], c_register[1])
# quantum circuit to measure q in the superposition basis
measureXX = program.create_circuit("measureXX", [q_register], [c_register])
measureXX.h(q_register[0])
measureXX.h(q_register[1])
measureXX.measure(q_register[0], c_register[0])
measureXX.measure(q_register[1], c_register[1])
program.add_circuit("bell_measureIZ", bell + measureIZ)
program.add_circuit("bell_measureIX", bell + measureIX)
program.add_circuit("bell_measureZI", bell + measureZI)
program.add_circuit("bell_measureXI", bell + measureXI)
program.add_circuit("bell_measureZZ", bell + measureZZ)
program.add_circuit("bell_measureXX", bell + measureXX)
circuits = [
"bell_measureIZ", "bell_measureIX", "bell_measureZI", "bell_measureXI",
"bell_measureZZ", "bell_measureXX"
]
program.get_qasms(circuits)
result = program.execute(circuits[0:2],
backend=backend,
shots=shots,
