def _test_circuits_2qubit():
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
# Test Circuits Bell state
circ = qp.create_circuit('Bell', [qr], [cr])
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ = qp.create_circuit('X1Id0', [qr], [cr])
circ.x(qr[1])
return qp, qr, cr
def test_create_several_circuits_noname(self):
"""Test create_circuit with several inputs and without names.
"""
q_program = QuantumProgram()
qr1 = q_program.create_quantum_register(size=3)
cr1 = q_program.create_classical_register(size=3)
qr2 = q_program.create_quantum_register(size=3)
cr2 = q_program.create_classical_register(size=3)
qc1 = q_program.create_circuit(qregisters=[qr1], cregisters=[cr1])
qc2 = q_program.create_circuit(qregisters=[qr2], cregisters=[cr2])
qc3 = q_program.create_circuit(qregisters=[qr1, qr2], cregisters=[cr1, cr2])
self.assertIsInstance(qc1, QuantumCircuit)
self.assertIsInstance(qc2, QuantumCircuit)
self.assertIsInstance(qc3, QuantumCircuit)
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit = qp.create_circuit('test_if', [qr], [cr])
circuit.x(qr[0])
circuit.x(qr[1])
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.x(qr[2]).c_if(cr, 0x3)
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
circuit.measure(qr[2], cr[2])
circuit2 = qp.create_circuit('test_if_case_2', [qr], [cr])
circuit2.x(qr[0])
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.x(qr[2]).c_if(cr, 0x3)
circuit2.measure(qr[0], cr[0])
circuit2.measure(qr[1], cr[1])
circuit2.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_case_2')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit2 = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': ucircuit, 'config': config}
result_if_true = QasmSimulator(job).run()
job = {'compiled_circuit': ucircuit2, 'config': config}
result_if_false = QasmSimulator(job).run()
self.log.info('result_if_true circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_true={0}'.format(result_if_true))
del circuit.data[1]
self.log.info('result_if_false circuit:')
self.log.info(circuit.qasm())
self.log.info('result_if_false={0}'.format(result_if_false))
self.assertTrue(result_if_true['data']['counts']['111'] == 100)
self.assertTrue(result_if_false['data']['counts']['001'] == 100)
def test_local_qasm_simulator(self):
"""Test execute.
If all correct should the data.
"""
QP_program = QuantumProgram(specs=QPS_SPECS)
qr = QP_program.get_quantum_register("qname")
cr = QP_program.get_classical_register("cname")
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc3 = QP_program.create_circuit("qc3", [qr], [cr])
qc2.h(qr[0])
qc2.cx(qr[0], qr[1])
qc2.cx(qr[0], qr[2])
qc3.h(qr)
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
qc3.measure(qr[1], cr[1])
qc2.measure(qr[2], cr[2])
qc3.measure(qr[2], cr[2])
circuits = ['qc2', 'qc3']
shots = 1024 # the number of shots in the experiment.
backend = 'local_qasm_simulator'
out = QP_program.execute(circuits, backend=backend, shots=shots,
seed=88)
results2 = out.get_counts('qc2')
results3 = out.get_counts('qc3')
# print(QP_program.get_data('qc3'))
self.assertEqual(results2, {'000': 518, '111': 506})
self.assertEqual(results3, {'001': 119, '111': 129, '110': 134,
'100': 117, '000': 129, '101': 126,
'010': 145, '011': 125})
def test_change_circuit_qobj_after_compile_noname(self):
q_program = QuantumProgram(specs=self.QPS_SPECS_NONAMES)
qr = q_program.get_quantum_register()
cr = q_program.get_classical_register()
qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc3 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc2.h(qr[0])
qc2.cx(qr[0], qr[1])
qc2.cx(qr[0], qr[2])
qc3.h(qr)
qc2.measure(qr, cr)
qc3.measure(qr, cr)
circuits = [qc2.name, qc3.name]
shots = 1024
backend = 'local_qasm_simulator'
config = {'seed': 10, 'shots': 1, 'xvals': [1, 2, 3, 4]}
qobj1 = q_program.compile(circuits, backend=backend, shots=shots, seed=88, config=config)
qobj1['circuits'][0]['config']['shots'] = 50
qobj1['circuits'][0]['config']['xvals'] = [1, 1, 1]
config['shots'] = 1000
config['xvals'][0] = 'only for qobj2'
qobj2 = q_program.compile(circuits, backend=backend, shots=shots, seed=88, config=config)
self.assertTrue(qobj1['circuits'][0]['config']['shots'] == 50)
self.assertTrue(qobj1['circuits'][1]['config']['shots'] == 1)
self.assertTrue(qobj1['circuits'][0]['config']['xvals'] == [1, 1, 1])
self.assertTrue(qobj1['circuits'][1]['config']['xvals'] == [1, 2, 3, 4])
self.assertTrue(qobj1['config']['shots'] == 1024)
self.assertTrue(qobj2['circuits'][0]['config']['shots'] == 1000)
self.assertTrue(qobj2['circuits'][1]['config']['shots'] == 1000)
self.assertTrue(qobj2['circuits'][0]['config']['xvals'] == [
'only for qobj2', 2, 3, 4])
self.assertTrue(qobj2['circuits'][1]['config']['xvals'] == [
'only for qobj2', 2, 3, 4])
def test_local_unitary_simulator(self):
"""Test unitary simulator.
If all correct should the h otimes h and cx.
"""
QP_program = QuantumProgram()
q = QP_program.create_quantum_register("q", 2, verbose=False)
c = QP_program.create_classical_register("c", 2, verbose=False)
qc1 = QP_program.create_circuit("qc1", [q], [c])
qc2 = QP_program.create_circuit("qc2", [q], [c])
qc1.h(q)
qc2.cx(q[0], q[1])
circuits = ['qc1', 'qc2']
backend = 'local_unitary_simulator' # the backend to run on
result = QP_program.execute(circuits, backend=backend)
unitary1 = result.get_data('qc1')['unitary']
unitary2 = result.get_data('qc2')['unitary']
unitaryreal1 = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, -0.5, 0.5, -0.5],
[0.5, 0.5, -0.5, -0.5],
[0.5, -0.5, -0.5, 0.5]])
unitaryreal2 = np.array([[1, 0, 0, 0], [0, 0, 0, 1],
[0., 0, 1, 0], [0, 1, 0, 0]])
norm1 = np.trace(np.dot(np.transpose(np.conj(unitaryreal1)), unitary1))
norm2 = np.trace(np.dot(np.transpose(np.conj(unitaryreal2)), unitary2))
self.assertAlmostEqual(norm1, 4)
self.assertAlmostEqual(norm2, 4)
def test_local_qasm_simulator_one_shot(self):
"""Test sinlge shot of local simulator .
If all correct should the quantum state.
"""
QP_program = QuantumProgram(specs=QPS_SPECS)
qr = QP_program.get_quantum_register("qname")
cr = QP_program.get_classical_register("cname")
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc3 = QP_program.create_circuit("qc3", [qr], [cr])
qc2.h(qr[0])
qc3.h(qr[0])
qc3.cx(qr[0], qr[1])
qc3.cx(qr[0], qr[2])
circuits = ['qc2', 'qc3']
backend = 'local_qasm_simulator' # the backend to run on
shots = 1 # the number of shots in the experiment.
result = QP_program.execute(circuits, backend=backend, shots=shots,
seed=9)
quantum_state = np.array([0.70710678+0.j, 0.70710678+0.j,
0.00000000+0.j, 0.00000000+0.j,
0.00000000+0.j, 0.00000000+0.j,
0.00000000+0.j, 0.00000000+0.j])
norm = np.dot(np.conj(quantum_state),
result.get_data('qc2')['quantum_state'])
self.assertAlmostEqual(norm, 1)
quantum_state = np.array([0.70710678+0.j, 0+0.j,
0.00000000+0.j, 0.00000000+0.j,
0.00000000+0.j, 0.00000000+0.j,
0.00000000+0.j, 0.70710678+0.j])
norm = np.dot(np.conj(quantum_state),
result.get_data('qc3')['quantum_state'])
self.assertAlmostEqual(norm, 1)
def test_get_qasms(self):
"""Test the get_qasms.
If all correct the qasm output for each circuit should be of a certain
lenght
Previusly:
Libraries:
from qiskit import QuantumProgram
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 3, verbose=False)
cr = QP_program.create_classical_register("cr", 3, verbose=False)
qc1 = QP_program.create_circuit("qc1", [qr], [cr])
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc1.h(qr[0])
qc1.cx(qr[0], qr[1])
qc1.cx(qr[1], qr[2])
qc1.measure(qr[0], cr[0])
qc1.measure(qr[1], cr[1])
qc1.measure(qr[2], cr[2])
qc2.h(qr)
qc2.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
qc2.measure(qr[2], cr[2])
result = QP_program.get_qasms(["qc1", "qc2"])
self.assertEqual(len(result[0]), 173)
self.assertEqual(len(result[1]), 159)
def test_compile_coupling_map(self):
"""Test compile_coupling_map.
If all correct should return data with the same stats. The circuit may
be different.
"""
QP_program = QuantumProgram()
q = QP_program.create_quantum_register("q", 3, verbose=False)
c = QP_program.create_classical_register("c", 3, verbose=False)
qc = QP_program.create_circuit("circuitName", [q], [c])
qc.h(q[0])
qc.cx(q[0], q[1])
qc.cx(q[0], q[2])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
qc.measure(q[2], c[2])
backend = 'local_qasm_simulator' # the backend to run on
shots = 1024 # the number of shots in the experiment.
coupling_map = {0: [1], 1: [2]}
initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1),
("q", 2): ("q", 2)}
circuits = ["circuitName"]
qobj = QP_program.compile(circuits, backend=backend, shots=shots,
coupling_map=coupling_map,
initial_layout=initial_layout, seed=88)
result = QP_program.run(qobj)
to_check = QP_program.get_qasm("circuitName")
self.assertEqual(len(to_check), 160)
self.assertEqual(result.get_counts("circuitName"),
{'000': 518, '111': 506})
def test_average_data(self):
"""Test average_data.
If all correct should the data.
"""
QP_program = QuantumProgram()
q = QP_program.create_quantum_register("q", 2, verbose=False)
c = QP_program.create_classical_register("c", 2, verbose=False)
qc = QP_program.create_circuit("qc", [q], [c])
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
circuits = ['qc']
shots = 10000 # the number of shots in the experiment.
backend = 'local_qasm_simulator'
results = QP_program.execute(circuits, backend=backend, shots=shots)
observable = {"00": 1, "11": 1, "01": -1, "10": -1}
meanzz = results.average_data("qc", observable)
observable = {"00": 1, "11": -1, "01": 1, "10": -1}
meanzi = results.average_data("qc", observable)
observable = {"00": 1, "11": -1, "01": -1, "10": 1}
meaniz = results.average_data("qc", observable)
self.assertAlmostEqual(meanzz, 1, places=1)
self.assertAlmostEqual(meanzi, 0, places=1)
self.assertAlmostEqual(meaniz, 0, places=1)
def test_get_register_and_circuit_names_nonames(self):
"""Get the names of the circuits and registers after create them without a name
"""
q_program = QuantumProgram()
qr1 = q_program.create_quantum_register(size=3)
cr1 = q_program.create_classical_register(size=3)
qr2 = q_program.create_quantum_register(size=3)
cr2 = q_program.create_classical_register(size=3)
q_program.create_circuit(qregisters=[qr1], cregisters=[cr1])
q_program.create_circuit(qregisters=[qr2], cregisters=[cr2])
q_program.create_circuit(qregisters=[qr1, qr2], cregisters=[cr1, cr2])
qrn = q_program.get_quantum_register_names()
crn = q_program.get_classical_register_names()
qcn = q_program.get_circuit_names()
self.assertEqual(len(qrn), 2)
self.assertEqual(len(crn), 2)
self.assertEqual(len(qcn), 3)
def test_create_circuit_noname(self):
"""Test create_circuit with no name
"""
q_program = QuantumProgram()
qr = q_program.create_quantum_register(size=3)
cr = q_program.create_classical_register(size=3)
qc = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
self.assertIsInstance(qc, QuantumCircuit)
def _get_quantum_program():
quantum_program = QuantumProgram()
qr = quantum_program.create_quantum_register("q", 1)
cr = quantum_program.create_classical_register("c", 1)
qc = quantum_program.create_circuit("qc", [qr], [cr])
qc.h(qr[0])
qc.measure(qr[0], cr[0])
return quantum_program
def test_create_several_circuits(self):
"""Test create_circuit with several inputs.
If all is correct we get a object intstance of QuantumCircuit
Previusly:
Libraries:
from qiskit import QuantumProgram
from qiskit import QuantumCircuit
"""
QP_program = QuantumProgram()
qr1 = QP_program.create_quantum_register("qr1", 3, verbose=False)
cr1 = QP_program.create_classical_register("cr1", 3, verbose=False)
qr2 = QP_program.create_quantum_register("qr2", 3, verbose=False)
cr2 = QP_program.create_classical_register("cr2", 3, verbose=False)
qc1 = QP_program.create_circuit("qc1", [qr1], [cr1])
qc2 = QP_program.create_circuit("qc2", [qr2], [cr2])
qc3 = QP_program.create_circuit("qc2", [qr1, qr2], [cr1, cr2])
self.assertIsInstance(qc1, QuantumCircuit)
self.assertIsInstance(qc2, QuantumCircuit)
self.assertIsInstance(qc3, QuantumCircuit)
def test_quantum_program_online(self):
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit('qc', [qr], [cr])
qc.h(qr[0])
qc.measure(qr[0], cr[0])
backend = 'ibmqx_qasm_simulator' # the backend to run on
shots = 1024 # the number of shots in the experiment.
qp.set_api(self.QE_TOKEN, self.QE_URL)
result = qp.execute(['qc'], backend=backend, shots=shots,
seed=78)
def test_simple_execute(self):
name = 'test_simple'
seed = 42
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit(name, [qr], [cr])
qc.u1(3.14, qr[0])
qc.u2(3.14, 1.57, qr[0])
qc.measure(qr, cr)
rtrue = qp.execute(name, seed=seed, skip_translation=True)
rfalse = qp.execute(name, seed=seed, skip_translation=False)
self.assertEqual(rtrue.get_counts(), rfalse.get_counts())
def test_get_register_and_circuit_names(self):
"""Get the names of the circuits and registers.
If all is correct we should get the arrays of the names
Previusly:
Libraries:
from qiskit import QuantumProgram
"""
QP_program = QuantumProgram()
qr1 = QP_program.create_quantum_register("qr1", 3, verbose=False)
cr1 = QP_program.create_classical_register("cr1", 3, verbose=False)
qr2 = QP_program.create_quantum_register("qr2", 3, verbose=False)
cr2 = QP_program.create_classical_register("cr2", 3, verbose=False)
QP_program.create_circuit("qc1", [qr1], [cr1])
QP_program.create_circuit("qc2", [qr2], [cr2])
QP_program.create_circuit("qc2", [qr1, qr2], [cr1, cr2])
qrn = QP_program.get_quantum_register_names()
crn = QP_program.get_classical_register_names()
qcn = QP_program.get_circuit_names()
self.assertEqual(qrn, {'qr1', 'qr2'})
self.assertEqual(crn, {'cr1', 'cr2'})
self.assertEqual(qcn, {'qc1', 'qc2'})
def main():
# create a program
qp = QuantumProgram()
# create 1 qubit
quantum_r = qp.create_quantum_register("qr", 5)
# create 1 classical register
classical_r = qp.create_classical_register("cr", 5)
# create a circuit
circuit = qp.create_circuit("Circuit", [quantum_r], [classical_r])
# enable logging
qp.enable_logs(logging.DEBUG)
# first physical gate: u1(lambda) to qubit 0
circuit.u2(-4 * math.pi / 3, 2 * math.pi, quantum_r[0])
circuit.u2(-3 * math.pi / 2, 2 * math.pi, quantum_r[0])
circuit.u3(-math.pi, 0, -math.pi, quantum_r[0])
circuit.u3(-math.pi, 0, -math.pi / 2, quantum_r[0])
circuit.u2(math.pi, -math.pi / 2, quantum_r[0])
circuit.u3(-math.pi, 0, -math.pi / 2, quantum_r[0])
# measure gate from qubit 0 to classical bit 0
circuit.measure(quantum_r[0], classical_r[0])
circuit.measure(quantum_r[1], classical_r[1])
circuit.measure(quantum_r[2], classical_r[2])
# backend simulator QASM: print(qp.get_qasm('Circuit'))
backend = 'ibmqx_qasm_simulator'
#backend = 'ibmqx4'
# Group of circuits to execute
circuits = ['Circuit']
# set the APIToken and Q Experience API url
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
result = qp.execute(circuits,
backend,
shots=512,
max_credits=3,
timeout=240)
# Show result counts
print("Job id=" + str(result.get_job_id()) + " Status:" +
result.get_status())
def qft3(g):
Q_program = QuantumProgram()
qr = Q_program.create_quantum_register("qr", 3)
cr = Q_program.create_classical_register("cr", 3)
qc = Q_program.create_circuit("superposition", [qr], [cr])
#Entradas
#qc.h(qr[1])
qc.h(qr[2])
#QFT 3
qc.h(qr[2]) #aplica H no 1 qubit
#S controlada de 0 para 1
qc.t(qr[2])
qc.cx(qr[1], qr[2])
qc.t(qr[1])
qc.tdg(qr[2])
qc.cx(qr[1], qr[2])
#T controlada de 0 para 2
qc.u1(pi/8, qr[2]) #u1=sqrt(T)
qc.cx(qr[0], qr[2])
qc.u1(pi/8, qr[0])
qc.u1(-pi/8, qr[2])
qc.cx(qr[0], qr[2])
qc.h(qr[1]) #aplica H no 2 qubit
#S controlada de 1 para 2
qc.t(qr[1])
qc.cx(qr[0], qr[1])
qc.t(qr[0])
qc.tdg(qr[1])
qc.cx(qr[0], qr[1])
qc.h(qr[0]) #aplica H no 3 qubit
qc.swap(qr[2], qr[0]) # troca o 1 e 3 qubit
qc.measure(qr, cr)
result = Q_program.execute(["superposition"], backend='local_qasm_simulator', shots=g)
print(result)
print(result.get_data("superposition"))
tmp = result.get_data("superposition")
plot_histogram(tmp['counts'])
def simulate(grid):
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit('pi', [qr], [cr])
qc = build_qc(qc, grid, qr, cr)
result = qp.execute('pi')
tmp = result.get_counts('pi')
tmp = dict([(x[0], round(x[1] / 1024, 2)) for x in list(tmp.items())])
return tmp
def test_create_circuit(self):
"""Test create_circuit.
If all is correct we get a object intstance of QuantumCircuit
Previusly:
Libraries:
from qiskit import QuantumProgram
from qiskit import QuantumCircuit
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 3, verbose=False)
cr = QP_program.create_classical_register("cr", 3, verbose=False)
qc = QP_program.create_circuit("qc", [qr], [cr])
self.assertIsInstance(qc, QuantumCircuit)
def _test_circuits_1qubit():
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 1)
cr = qp.create_classical_register('cr', 1)
# Test Circuits Z eigenstate
circ = qp.create_circuit('Zp', [qr], [cr])
circ = qp.create_circuit('Zm', [qr], [cr])
circ.x(qr[0])
# Test Circuits X eigenstate
circ = qp.create_circuit('Xp', [qr], [cr])
circ.h(qr[0])
circ = qp.create_circuit('Xm', [qr], [cr])
circ.h(qr[0])
circ.z(qr[0])
# Test Circuits Y eigenstate
circ = qp.create_circuit('Yp', [qr], [cr])
circ.h(qr[0])
circ.s(qr[0])
circ = qp.create_circuit('Ym', [qr], [cr])
circ.h(qr[0])
circ.s(qr[0])
circ.z(qr[0])
return qp, qr, cr
def _test_circuits_1qubit():
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 1)
cr = qp.create_classical_register('cr', 1)
# Test Circuits Z eigenstate
circ = qp.create_circuit('Zp', [qr], [cr])
circ = qp.create_circuit('Zm', [qr], [cr])
circ.x(qr[0])
# Test Circuits X eigenstate
circ = qp.create_circuit('Xp', [qr], [cr])
circ.h(qr[0])
circ = qp.create_circuit('Xm', [qr], [cr])
circ.h(qr[0])
circ.z(qr[0])
# Test Circuits Y eigenstate
circ = qp.create_circuit('Yp', [qr], [cr])
circ.h(qr[0])
circ.s(qr[0])
circ = qp.create_circuit('Ym', [qr], [cr])
circ.h(qr[0])
circ.s(qr[0])
circ.z(qr[0])
return qp, qr, cr
def simulate(grid):
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit('pi', [qr], [cr])
qc = build_qc(qc, grid, qr, cr)
result = qp.execute('pi')
tmp = result.get_counts('pi')
tmp = dict([(x[0], round(x[1] / 1024, 2)) for x in list(tmp.items())])
return tmp
def test_initialize_middle_circuit(self):
desired_vector = [0.5, 0.5, 0.5, 0.5]
qp = QuantumProgram()
qr = qp.create_quantum_register("qr", 2)
cr = qp.create_classical_register("cr", 2)
qc = qp.create_circuit("qc", [qr], [cr])
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.initialize("QInit", desired_vector, [qr[0], qr[1]])
result = qp.execute(["qc"], backend='local_qasm_simulator', shots=1)
quantum_state = result.get_data("qc")['quantum_state']
fidelity = state_fidelity(quantum_state, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_create_circuit(self):
"""Test create_circuit.
If all is correct we get a object intstance of QuantumCircuit
Previusly:
Libraries:
from qiskit import QuantumProgram
from qiskit import QuantumCircuit
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 3, verbose=False)
cr = QP_program.create_classical_register("cr", 3, verbose=False)
qc = QP_program.create_circuit("qc", [qr], [cr])
self.assertIsInstance(qc, QuantumCircuit)
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_simple_execute(self):
name = 'test_simple'
seed = 42
self.log.info(name)
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit(name, [qr], [cr])
qc.u1(3.14, qr[0])
qc.u2(3.14, 1.57, qr[0])
qc.measure(qr, cr)
rtrue = qp.execute(name, seed=seed, skip_translation=True)
rfalse = qp.execute(name, seed=seed, skip_translation=False)
self.assertEqual(rtrue.get_counts(), rfalse.get_counts())
def main():
# Quantum program setup
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])
# Creating registers
q = Q_program.create_quantum_register("q", 2)
c = Q_program.create_classical_register("c", 2)
# Quantum circuit to make the shared entangled state
superdense = Q_program.create_circuit("superdense", [q], [c])
superdense.h(q[0])
superdense.cx(q[0], q[1])
# For 00, do nothing
# For 10, apply X
#shared.x(q[0])
# For 01, apply Z
#shared.z(q[0])
# For 11, apply XZ
superdense.z(q[0])
superdense.x(q[0])
superdense.barrier()
superdense.cx(q[0], q[1])
superdense.h(q[0])
superdense.measure(q[0], c[0])
superdense.measure(q[1], c[1])
circuits = ["superdense"]
print(Q_program.get_qasms(circuits)[0])
backend = "local_qasm_simulator" #'ibmqx2' # the device to run on
shots = 1024 # the number of shots in the experiment
result = Q_program.execute(circuits,
backend=backend,
shots=shots,
max_credits=3,
wait=10,
timeout=240)
print("Counts:" + str(result.get_counts("superdense")))
plot_histogram(result.get_counts("superdense"))
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr], [cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi / 4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator'
qobj = qp.compile('teleport',
backend=backend,
shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info(circuit.qasm())
self.log.info('test_teleport: data {0}'.format(data))
self.log.info('test_teleport: alice {0}'.format(alice))
self.log.info('test_teleport: bob {0}'.format(bob))
alice_ratio = 1 / np.tan(pi / 8)**2
bob_ratio = bob['0'] / float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = {0:.4f}'.format(error))
self.assertLess(error, 0.05)
def testtiffolihelper(tiffun, rs):
Q = QuantumProgram()
qr = Q.create_quantum_register("qr", 3)
cr = Q.create_classical_register("cr", 3)
qc = Q.create_circuit("tiffolitest", [qr], [cr])
if rs[2] == 1:
goodresult = str(1 - rs[1] * rs[0]) + str(rs[1]) + str(rs[0])
else:
goodresult = str(rs[1] * rs[0]) + str(rs[1]) + str(rs[0])
for i in range(3):
if rs[i] == 1:
qc.x(qr[i])
tiffun(qc, qr[0], qr[1], qr[2])
qc.measure(qr, cr)
result = Q.execute(["tiffolitest"], backend="local_qasm_simulator", shots=100).get_data("tiffolitest")
return goodresult in result["counts"] and result["counts"][goodresult] == 100
def test_teleport(self):
"""test teleportation as in tutorials"""
self.log.info('test_teleport')
pi = np.pi
shots = 1000
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 3)
cr0 = qp.create_classical_register('cr0', 1)
cr1 = qp.create_classical_register('cr1', 1)
cr2 = qp.create_classical_register('cr2', 1)
circuit = qp.create_circuit('teleport', [qr],
[cr0, cr1, cr2])
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])
circuit.ry(pi/4, qr[0])
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr0[0])
circuit.measure(qr[1], cr1[0])
circuit.z(qr[2]).c_if(cr0, 1)
circuit.x(qr[2]).c_if(cr1, 1)
circuit.measure(qr[2], cr2[0])
backend = 'local_qasm_simulator'
qobj = qp.compile('teleport', backend=backend, shots=shots,
seed=self.seed)
results = qp.run(qobj)
data = results.get_counts('teleport')
alice = {}
bob = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['01'] = data['0 1 0'] + data['1 1 0']
alice['10'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
self.log.info('test_telport: circuit:')
self.log.info( circuit.qasm() )
self.log.info('test_teleport: data {0}'.format(data))
self.log.info('test_teleport: alice {0}'.format(alice))
self.log.info('test_teleport: bob {0}'.format(bob))
alice_ratio = 1/np.tan(pi/8)**2
bob_ratio = bob['0']/float(bob['1'])
error = abs(alice_ratio - bob_ratio) / alice_ratio
self.log.info('test_teleport: relative error = {0:.4f}'.format(error))
self.assertLess(error, 0.05)
def invqft3(g):
Q_program = QuantumProgram()
qr = Q_program.create_quantum_register("qr", 3)
cr = Q_program.create_classical_register("cr", 3)
qc = Q_program.create_circuit("superposition", [qr], [cr])
#entradas
qc.h(qr[1])
qc.h(qr[2])
qc.swap(qr[2], qr[0]) # troca o 1 e 3 qubit
qc.h(qr[0])
qc.tdg(qr[1])
qc.cx(qr[0], qr[1])
qc.tdg(qr[0])
qc.t(qr[1])
qc.cx(qr[0], qr[1])
qc.h(qr[1])
qc.u1(-pi/8, qr[2])
qc.cx(qr[0], qr[2])
qc.u1(-pi/8, qr[0])
qc.u1(pi/8, qr[2])
qc.cx(qr[0], qr[2])
qc.tdg(qr[2])
qc.cx(qr[1], qr[2])
qc.tdg(qr[1])
qc.t(qr[2])
qc.cx(qr[1], qr[2])
qc.h(qr[2])
qc.measure(qr, cr)
result = Q_program.execute(["superposition"], backend='local_qasm_simulator', shots=g)
print(result)
print(result.get_data("superposition"))
tmp = result.get_data("superposition")
plot_histogram(tmp['counts'])
def gen_bv_main(nQubits, hiddenString):
"""
generate a circuit of the Bernstein-Vazirani algorithm
"""
Q_program = QuantumProgram()
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = Q_program.create_quantum_register("qr", nQubits)
# for recording the measurement on qr
cr = Q_program.create_classical_register("cr", nQubits - 1)
circuitName = "BernsteinVazirani"
bvCircuit = Q_program.create_circuit(circuitName, [qr], [cr])
# Apply Hadamard gates to the first
# (nQubits - 1) before querying the oracle
for i in range(nQubits - 1):
bvCircuit.h(qr[i])
# Apply 1 and Hadamard gate to the last qubit
# for storing the oracle's answer
bvCircuit.x(qr[nQubits - 1])
bvCircuit.h(qr[nQubits - 1])
# Apply barrier so that it is not optimized by the compiler
bvCircuit.barrier()
# Apply the inner-product oracle
hiddenString = hiddenString[::-1]
for i in range(len(hiddenString)):
if hiddenString[i] == "1":
bvCircuit.cx(qr[i], qr[nQubits - 1])
hiddenString = hiddenString[::-1]
# Apply barrier
bvCircuit.barrier()
# Apply Hadamard gates after querying the oracle
for i in range(nQubits - 1):
bvCircuit.h(qr[i])
# Measurement
for i in range(nQubits - 1):
bvCircuit.measure(qr[i], cr[i])
return Q_program, [
circuitName,
]
def test_execute_several_circuits_simulator_online(self):
QP_program = QuantumProgram(specs=QPS_SPECS)
qr = QP_program.get_quantum_register("qname")
cr = QP_program.get_classical_register("cname")
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc3 = QP_program.create_circuit("qc3", [qr], [cr])
qc2.h(qr[0])
qc3.h(qr[0])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
circuits = ['qc2', 'qc3']
shots = 1024 # the number of shots in the experiment.
QP_program.set_api(API_TOKEN, URL)
backend = QP_program.online_simulators()[0]
result = QP_program.execute(circuits, backend=backend, shots=shots,
max_credits=3, silent=True)
self.assertIsInstance(result, Result)
def test_execute_several_circuits_simulator_online(self):
QP_program = QuantumProgram(specs=QPS_SPECS)
qr = QP_program.get_quantum_register("qname")
cr = QP_program.get_classical_register("cname")
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc3 = QP_program.create_circuit("qc3", [qr], [cr])
qc2.h(qr[0])
qc3.h(qr[0])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
circuits = ['qc2', 'qc3']
shots = 1024 # the number of shots in the experiment.
QP_program.set_api(API_TOKEN, URL)
backend = QP_program.online_simulators()[0]
result = QP_program.execute(circuits, backend=backend, shots=shots,
max_credits=3, silent=True)
self.assertIsInstance(result, Result)
def cnot_experiment(num, init):
qp = QuantumProgram()
qp.set_api(QConfig.APItoken, QConfig.config['url'])
qr = qp.create_quantum_register('qr', num)
cr = qp.create_classical_register('qc', num)
qc = qp.create_circuit('CNOT', [qr], [cr])
init(qc, qr)
for i in range(num - 1):
qc.cx(qr[i], qr[i + 1])
for i in range(num):
qc.measure(qr[i], cr[i])
return qp
def test_entangle(self):
N = 5
qp = QuantumProgram()
qr = qp.create_quantum_register("qr", N)
cr = qp.create_classical_register("cr", N)
qc = qp.create_circuit("circuitName", [qr], [cr])
qc.h(qr[0])
for i in range(1, N):
qc.cx(qr[0], qr[i])
qc.measure(qr, cr)
result = qp.execute(['circuitName'],
backend='local_projectq_simulator',
seed=1, shots=100)
counts = result.get_counts(result.get_names()[0])
self.log.info(counts)
for key, _ in counts.items():
with self.subTest(key=key):
self.assertTrue(key in ['0' * N, '1' * N])
def QISKit_NOT_Gate(x):
backend = 'local_qasm_simulator'
Circuit = 'NOT_GATE'
qProgram = QuantumProgram()
qRegister = qProgram.create_quantum_register('q1', 1)
cRegister = qProgram.create_classical_register('c1', 1)
qCircuit = qProgram.create_circuit(Circuit, [qRegister], [cRegister])
if (x == 1):
qCircuit.x(qRegister[0])
qCircuit.x(qRegister[0])
qCircuit.measure(qRegister[0], cRegister[0])
qobj = qProgram.compile([Circuit], backend=backend)
result = qProgram.run(qobj, wait=2, timeout=240)
dic_result = result.get_counts(Circuit)
max_prob_key = max(dic_result, key=dic_result.get)
return int(max_prob_key)
def test_random_4qubit(self):
desired_vector = [
1 / math.sqrt(4) * complex(0, 1), 1 / math.sqrt(8) * complex(1, 0),
0, 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) * complex(1, 0), 1 / math.sqrt(8) * complex(1, 0)
]
qp = QuantumProgram()
qr = qp.create_quantum_register("qr", 4)
cr = qp.create_classical_register("cr", 4)
qc = qp.create_circuit("qc", [qr], [cr])
qc.initialize(desired_vector, [qr[0], qr[1], qr[2], qr[3]])
result = qp.execute(["qc"], backend='local_qasm_simulator', shots=1)
quantum_state = result.get_data("qc")['quantum_state']
fidelity = state_fidelity(quantum_state, desired_vector)
self.assertGreater(
fidelity, self._desired_fidelity,
"Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_change_circuit_qobj_after_compile_noname(self):
q_program = QuantumProgram(specs=self.QPS_SPECS_NONAMES)
qr = q_program.get_quantum_register()
cr = q_program.get_classical_register()
qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc3 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc2.h(qr[0])
qc2.cx(qr[0], qr[1])
qc2.cx(qr[0], qr[2])
qc3.h(qr)
qc2.measure(qr, cr)
qc3.measure(qr, cr)
circuits = [qc2.name, qc3.name]
shots = 1024
backend = 'local_qasm_simulator'
config = {'seed': 10, 'shots': 1, 'xvals': [1, 2, 3, 4]}
qobj1 = q_program.compile(circuits,
backend=backend,
shots=shots,
seed=88,
config=config)
qobj1 = qobj1.as_dict()
qobj1['circuits'][0]['config']['shots'] = 50
qobj1['circuits'][0]['config']['xvals'] = [1, 1, 1]
config['shots'] = 1000
config['xvals'][0] = 'only for qobj2'
qobj2 = q_program.compile(circuits,
backend=backend,
shots=shots,
seed=88,
config=config)
qobj2 = qobj2.as_dict()
self.assertTrue(qobj1['circuits'][0]['config']['shots'] == 50)
self.assertTrue(qobj1['circuits'][1]['config']['shots'] == 1)
self.assertTrue(qobj1['circuits'][0]['config']['xvals'] == [1, 1, 1])
self.assertTrue(
qobj1['circuits'][1]['config']['xvals'] == [1, 2, 3, 4])
self.assertTrue(qobj1['config']['shots'] == 1024)
self.assertTrue(qobj2['circuits'][0]['config']['shots'] == 1000)
self.assertTrue(qobj2['circuits'][1]['config']['shots'] == 1000)
self.assertTrue(qobj2['circuits'][0]['config']['xvals'] ==
['only for qobj2', 2, 3, 4])
self.assertTrue(qobj2['circuits'][1]['config']['xvals'] ==
['only for qobj2', 2, 3, 4])
def test_simple_compile(self):
"""
Compares with and without skip_transpiler
"""
name = 'test_simple'
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit(name, [qr], [cr])
qc.u1(3.14, qr[0])
qc.u2(3.14, 1.57, qr[0])
qc.measure(qr, cr)
rtrue = qp.compile([name], backend='local_qasm_simulator', shots=1024,
skip_transpiler=True)
rfalse = qp.compile([name], backend='local_qasm_simulator', shots=1024,
skip_transpiler=False)
self.assertEqual(rtrue.config, rfalse.config)
self.assertEqual(rtrue.experiments, rfalse.experiments)
def test_local_qasm_simulator_one_shot(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[0])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
circuits = ['qc2', 'qc3']
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)
print(QP_program.get_qasms(['qc2', 'qc3']))
self.assertEqual(result['status'], 'COMPLETED')
def test_execute_program_simulator_online(self):
QP_program = QuantumProgram(specs=QPS_SPECS)
qc = QP_program.get_circuit("circuitName")
qr = QP_program.get_quantum_registers("qname")
cr = QP_program.get_classical_registers("cname")
qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"])
qc2.h(qr[0])
qc3.h(qr[0])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
device = 'simulator' # the device to run on
shots = 1 # the number of shots in the experiment.
apiconnection = QP_program.set_api(API_TOKEN, URL)
result = QP_program.execute(['qc2'], device, shots, max_credits=3)
self.assertEqual(result["status"], "COMPLETED")
def test_simple_compile(self):
"""
Compares with and without skip_translation
"""
name = 'test_simple'
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit(name, [qr], [cr])
qc.u1(3.14, qr[0])
qc.u2(3.14, 1.57, qr[0])
qc.measure(qr, cr)
rtrue = qp.compile([name], backend='local_qasm_simulator', shots=1024,
skip_translation=True)
rfalse = qp.compile([name], backend='local_qasm_simulator', shots=1024,
skip_translation=False)
self.assertEqual(rtrue['config'], rfalse['config'])
self.assertEqual(rtrue['circuits'], rfalse['circuits'])
def test_local_qasm_simulator(self):
"""Test execute.
If all correct should the data.
"""
QP_program = QuantumProgram(specs=QPS_SPECS)
qr = QP_program.get_quantum_register("qname")
cr = QP_program.get_classical_register("cname")
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc3 = QP_program.create_circuit("qc3", [qr], [cr])
qc2.h(qr[0])
qc2.cx(qr[0], qr[1])
qc2.cx(qr[0], qr[2])
qc3.h(qr)
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
qc3.measure(qr[1], cr[1])
qc2.measure(qr[2], cr[2])
qc3.measure(qr[2], cr[2])
circuits = ['qc2', 'qc3']
shots = 1024 # the number of shots in the experiment.
backend = 'local_qasm_simulator'
out = QP_program.execute(circuits,
backend=backend,
shots=shots,
seed=88)
results2 = out.get_counts('qc2')
results3 = out.get_counts('qc3')
# print(QP_program.get_data('qc3'))
self.assertEqual(results2, {'000': 518, '111': 506})
self.assertEqual(
results3, {
'001': 119,
'111': 129,
'110': 134,
'100': 117,
'000': 129,
'101': 126,
'010': 145,
'011': 125
})
def initializeQuantumProgram ( device, sim ):
# *This function contains SDK specific code.*
#
# Input:
# * *device* - String specifying the device on which the game is played.
# Details about the device will be obtained using getLayout.
# * *sim* - Whether this is a simulated run
# Process:
# * Initializes everything required by the SDK for the quantum program. The details depend on which SDK is used.
# Output:
# * *q* - Register of qubits (needed by both QISKit and ProjectQ).
# * *c* - Register of classical bits (needed by QISKit only).
# * *engine* - Class required to create programs in QISKit, ProjectQ and Forest.
# * *script* - The quantum program, needed by QISKit and Forest.
num, area, entangleType, pairs, pos, example, sdk, runs = getLayout(device)
importSDK ( device )
if sdk in ["QISKit","ManualQISKit"]:
engine = QuantumProgram()
engine.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url
q = engine.create_quantum_register("q", num)
c = engine.create_classical_register("c", num)
script = engine.create_circuit("script", [q], [c])
elif sdk=="ProjectQ":
engine = projectq.MainEngine()
q = engine.allocate_qureg( num )
c = None
script = None
elif sdk=="Forest":
if sim:
engine = api.QVMConnection(use_queue=True)
else:
engine = api.QPUConnection(device)
script = Program()
q = range(num)
c = range(num)
return q, c, engine, script
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 main():
# create a program
qp = QuantumProgram()
# create 1 qubit
quantum_r = qp.create_quantum_register("qr", 1)
# create 1 classical register
classical_r = qp.create_classical_register("cr", 1)
# create a circuit
circuit = qp.create_circuit("Circuit", [quantum_r], [classical_r])
# enable logging
qp.enable_logs(logging.DEBUG)
# Pauli X gate to qubit 1 in the Quantum Register "qr"
circuit.x(quantum_r[0])
# measure gate from qubit 0 to classical bit 0
circuit.measure(quantum_r[0], classical_r[0])
# backend simulator
backend = 'ibmqx_qasm_simulator'
# Group of circuits to execute
circuits = ['Circuit']
# set the APIToken and Q Experience API url
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
result = qp.execute(circuits,
backend,
shots=512,
max_credits=3,
timeout=240)
# Show result counts
print(str(result.get_counts('Circuit')))
def quantumFindPeriod(a, N):
# Quantum Subroutine
Q_program = QuantumProgram()
backend = 'local_qasm_simulator'
try:
qr = Q_program.create_quantum_register("qr", 4)
cr = Q_program.create_classical_register("cr", 4)
qc = Q_program.create_circuit("shor", [qr], [cr])
for i in range(a):
qc.x(qr[0])
for i in range(a**(N**(1/2))):
qc.x(qr[1])
for i in range(a/N):
qc.x(qr[2])
for i in range(N/a):
qc.x(qr[3])
qc.cx(qr[2], qr[1])
qc.cx(qr[1], qr[3])
qc.cx(qr[2], qr[1])
qc.cx(qr[1], qr[0])
qc.cx(qr[0], qr[1])
qc.cx(qr[1], qr[0])
qc.cx(qr[3], qr[0])
qc.cx(qr[0], qr[3])
qc.cx(qr[3], qr[0])
qc.measure(qr, cr)
result = Q_program.execute(["shor"], backend=backend, shots=1024, seed=1)
print(result)
print(result.get_counts("shor"))
except QISKitError as ex:
print('There was an error in the circuit! Error = {}'.format(ex))
return result
def test_combine_results(self):
"""Test run.
If all correct should the data.
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 1)
cr = QP_program.create_classical_register("cr", 1)
qc1 = QP_program.create_circuit("qc1", [qr], [cr])
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc1.measure(qr[0], cr[0])
qc2.x(qr[0])
qc2.measure(qr[0], cr[0])
shots = 1024 # the number of shots in the experiment.
backend = 'local_qasm_simulator'
res1 = QP_program.execute(['qc1'], backend=backend, shots=shots)
res2 = QP_program.execute(['qc2'], backend=backend, shots=shots)
counts1 = res1.get_counts('qc1')
counts2 = res2.get_counts('qc2')
res1 += res2 # combine results
counts12 = [res1.get_counts('qc1'), res1.get_counts('qc2')]
self.assertEqual(counts12, [counts1, counts2])
def test_local_unitary_simulator(self):
QP_program = QuantumProgram(specs=QPS_SPECS)
qc = QP_program.get_circuit("circuitName")
qr = QP_program.get_quantum_registers("qname")
cr = QP_program.get_classical_registers("cname")
qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"])
qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"])
qc2.h(qr[0])
qc3.h(qr[0])
qc2.measure(qr[0], cr[0])
qc3.measure(qr[0], cr[0])
circuits = ['qc2', 'qc3']
device = 'local_unitary_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)
# print(result)
self.assertEqual(result['status'], 'COMPLETED')
def test_combine_results(self):
"""Test run.
If all correct should the data.
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 1)
cr = QP_program.create_classical_register("cr", 1)
qc1 = QP_program.create_circuit("qc1", [qr], [cr])
qc2 = QP_program.create_circuit("qc2", [qr], [cr])
qc1.measure(qr[0], cr[0])
qc2.x(qr[0])
qc2.measure(qr[0], cr[0])
shots = 1024 # the number of shots in the experiment.
backend = 'local_qasm_simulator'
res1 = QP_program.execute(['qc1'], backend=backend, shots=shots)
res2 = QP_program.execute(['qc2'], backend=backend, shots=shots)
counts1 = res1.get_counts('qc1')
counts2 = res2.get_counts('qc2')
res1 += res2 # combine results
counts12 = [res1.get_counts('qc1'), res1.get_counts('qc2')]
self.assertEqual(counts12, [counts1, counts2])
def test_compile_coupling_map(self):
"""Test compile_coupling_map.
If all correct should return data with the same stats. The circuit may
be different.
"""
QP_program = QuantumProgram()
q = QP_program.create_quantum_register("q", 3, verbose=False)
c = QP_program.create_classical_register("c", 3, verbose=False)
qc = QP_program.create_circuit("circuitName", [q], [c])
qc.h(q[0])
qc.cx(q[0], q[1])
qc.cx(q[0], q[2])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
qc.measure(q[2], c[2])
backend = 'local_qasm_simulator' # the backend to run on
shots = 1024 # the number of shots in the experiment.
coupling_map = {0: [1], 1: [2]}
initial_layout = {
("q", 0): ("q", 0),
("q", 1): ("q", 1),
("q", 2): ("q", 2)
}
circuits = ["circuitName"]
qobj = QP_program.compile(circuits,
backend=backend,
shots=shots,
coupling_map=coupling_map,
initial_layout=initial_layout,
seed=88)
result = QP_program.run(qobj)
to_check = QP_program.get_qasm("circuitName")
self.assertEqual(len(to_check), 160)
self.assertEqual(result.get_counts("circuitName"), {
'000': 518,
'111': 506
})
def test_get_qasms_noname(self):
"""Test the get_qasms from a qprogram without names.
"""
q_program = QuantumProgram()
qr = q_program.create_quantum_register(size=3)
cr = q_program.create_classical_register(size=3)
qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
qc1.h(qr[0])
qc1.cx(qr[0], qr[1])
qc1.cx(qr[1], qr[2])
qc1.measure(qr[0], cr[0])
qc1.measure(qr[1], cr[1])
qc1.measure(qr[2], cr[2])
qc2.h(qr)
qc2.measure(qr[0], cr[0])
qc2.measure(qr[1], cr[1])
qc2.measure(qr[2], cr[2])
results = dict(zip(q_program.get_circuit_names(), q_program.get_qasms()))
qr_name_len = len(qr.name)
cr_name_len = len(cr.name)
self.assertEqual(len(results[qc1.name]), qr_name_len * 9 + cr_name_len * 4 + 147)
self.assertEqual(len(results[qc2.name]), qr_name_len * 7 + cr_name_len * 4 + 137)
def test_execute_one_circuit_real_online(self):
"""Test execute_one_circuit_real_online.
If all correct should return a result object
"""
QP_program = QuantumProgram()
qr = QP_program.create_quantum_register("qr", 1, verbose=False)
cr = QP_program.create_classical_register("cr", 1, verbose=False)
qc = QP_program.create_circuit("circuitName", [qr], [cr])
qc.h(qr)
qc.measure(qr[0], cr[0])
QP_program.set_api(API_TOKEN, URL)
backend_list = QP_program.online_backends()
if backend_list:
backend = backend_list[0]
shots = 1 # the number of shots in the experiment.
status = QP_program.get_backend_status(backend)
if status['available'] is False:
pass
else:
result = QP_program.execute(['circuitName'], backend=backend,
shots=shots, max_credits=3)
self.assertIsInstance(result, Result)
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_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qp = QuantumProgram()
qr = qp.create_quantum_register('qr', max_qubits)
cr = qp.create_classical_register('cr', max_qubits)
circuit_if_true = qp.create_circuit('test_if_true', [qr], [cr])
circuit_if_true.x(qr[0])
circuit_if_true.x(qr[1])
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.x(qr[2]).c_if(cr, 0x3)
circuit_if_true.measure(qr[0], cr[0])
circuit_if_true.measure(qr[1], cr[1])
circuit_if_true.measure(qr[2], cr[2])
circuit_if_false = qp.create_circuit('test_if_false', [qr], [cr])
circuit_if_false.x(qr[0])
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.x(qr[2]).c_if(cr, 0x3)
circuit_if_false.measure(qr[0], cr[0])
circuit_if_false.measure(qr[1], cr[1])
circuit_if_false.measure(qr[2], cr[2])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_true')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_true = unroller.execute()
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if_false')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_false = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
qobj = {'id': 'test_if_qobj',
'config': {
'max_credits': 3,
'shots': shots,
'backend': 'local_qasm_simulator',
},
'circuits': [
{
'name': 'test_if_true',
'compiled_circuit': ucircuit_true,
'compiled_circuit_qasm': None,
'config': {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
},
{
'name': 'test_if_false',
'compiled_circuit': ucircuit_false,
'compiled_circuit_qasm': None,
'config': {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': None
}
}
]
}
q_job = QuantumJob(qobj, preformatted=True)
result = QasmSimulator().run(q_job)
result_if_true = result.get_data('test_if_true')
self.log.info('result_if_true circuit:')
self.log.info(circuit_if_true.qasm())
self.log.info('result_if_true={0}'.format(result_if_true))
result_if_false = result.get_data('test_if_false')
self.log.info('result_if_false circuit:')
self.log.info(circuit_if_false.qasm())
self.log.info('result_if_false={0}'.format(result_if_false))
self.assertTrue(result_if_true['counts']['111'] == 100)
self.assertTrue(result_if_false['counts']['001'] == 100)
class RandomQasmGenerator():
"""
Generate circuits with random operations for profiling.
"""
def __init__(self, seed=None, qubits=16, depth=40):
"""
Args:
seed: Random number seed. If none, don't seed the generator.
depth: Number of operations in the circuit.
qubits: Number of qubits in the circuit.
"""
self.depth = depth
self.qubits = qubits
self.quantum_program = QuantumProgram()
self.quantum_register = self.quantum_program.create_quantum_register(
'qr', qubits)
self.classical_register = self.quantum_program.create_classical_register(
'cr', qubits)
if seed is not None:
random.seed(a=seed)
def create_circuit(self, do_measure=True):
"""Creates a circuit
Generates a circuit with a random number of operations equally weighted
between U3 and CX. Also adds a random number of measurements in
[1,self.qubits] to end of circuit.
Args:
do_measure (boolean): whether to add measurements
Returns:
A string representing the QASM circuit
"""
circuit_name = str(uuid.uuid4())
circuit = self.quantum_program.create_circuit(circuit_name,
[self.quantum_register],
[self.classical_register])
for j in range(self.depth):
if self.qubits == 1:
op_ind = 0
else:
op_ind = random.randint(0, 1)
if op_ind == 0: # U3
qind = random.randint(0, self.qubits - 1)
circuit.u3(random.random(), random.random(), random.random(),
self.quantum_register[qind])
elif op_ind == 1: # CX
source, target = random.sample(range(self.qubits), 2)
circuit.cx(self.quantum_register[source],
self.quantum_register[target])
if do_measure:
nmeasure = random.randint(1, self.qubits)
for j in range(nmeasure):
qind = random.randint(0, self.qubits - 1)
# doing this if here keeps the RNG from depending on
# whether measurements are done.
circuit.measure(self.quantum_register[qind],
self.classical_register[qind])
return circuit.qasm()
