def a_8():
qreg = qk.QuantumRegister(8)
creg = qk.ClassicalRegister(3)
qc = qk.QuantumCircuit(qreg, creg)
# initialize
qc.x(7)
qc.h([0, 1, 2])
# multiplier
qc.cx(2, 7)
qc.cx(2, 4)
inv_qft = qft.qft(3)
qc.append(inv_qft, qargs=qreg[:3])
for i in range(3):
qc.measure(i, i)
# qc.draw(output='mpl')
# plt.savefig('../presentation/20200528/figs/11circuit.pdf')
return qc
def test_qasm_reset_measure(self):
"""counts from a qasm program with measure and reset in the middle"""
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.reset(qr[0])
circuit.cx(qr[1], qr[2])
circuit.t(qr)
circuit.measure(qr[1], cr[1])
circuit.h(qr[2])
circuit.measure(qr[2], cr[2])
sim_cpp = qiskit.providers.aer.QasmSimulator()
sim_py = qiskit.providers.builtinsimulators.QasmSimulatorPy()
shots = 1000
result_cpp = execute(circuit, sim_cpp, shots=shots, seed=1).result()
result_py = execute(circuit, sim_py, shots=shots, seed=1).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.06)
def test_compile_run_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Compiler and run remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
backend = provider.available_backends({'simulator': True})[0]
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile(qc, backend)
job = backend.run(qobj)
result = job.result(timeout=20)
self.assertIsInstance(result, Result)
def __init__(self, n_work, n_simulation, delta=1, g=1, dt=0.005, Emax=500):
"""
Input:
input:
n_work (int) - Number of work-qubits
n_simulation (int) - Number of simulation qubits
delta (float) - parameter in the one-body hamiltonian
g (float) - parameter in the two-body hamiltonian
dt (float) - timestep in the phase estimation algorithm
Emax (float) - subtracted from the hamiltonian to yield the whole eigenvalue sprectrum.
"""
self.n_work = n_work
self.n_simulation = n_simulation
self.n_qubits = n_work + n_simulation + 1
self.qb = qk.QuantumRegister(self.n_qubits)
self.cb = qk.ClassicalRegister(self.n_qubits)
self.qz = qk.QuantumCircuit(self.qb, self.cb)
self.delta = delta
self.g = g
self.dt = dt
self.Emax = Emax
def test_average_data_matrix_observable(self):
"""Test average_data for matrix observable input."""
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qr, cr, name="qc")
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
shots = 10000
backend = BasicAer.get_backend("qasm_simulator")
result = qiskit.execute(qc, backend, shots=shots).result()
counts = result.get_counts(qc)
observable = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]
mean_zz = average_data(counts=counts, observable=observable)
observable = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]
mean_zi = average_data(counts, observable)
observable = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]]
mean_iz = average_data(counts, observable)
self.assertAlmostEqual(mean_zz, 1, places=1)
self.assertAlmostEqual(mean_zi, 0, places=1)
self.assertAlmostEqual(mean_iz, 0, places=1)
def test_compile_two_run_remote(self, qe_token, qe_url):
"""Test Compiler and run two circuits.
If all correct some should exists.
"""
register(qe_token, qe_url)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra")
qc_extra.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile([qc, qc_extra],
backend,
seed=TestCompiler.seed)
job = backend.run(qobj)
result = job.result()
self.assertIsInstance(result, Result)
def test_mapping_already_satisfied(self):
"""Test compiler doesn't change circuit already matching backend coupling
"""
backend = FakeBackEnd()
qr = qiskit.QuantumRegister(16)
cr = qiskit.ClassicalRegister(16)
qc = qiskit.QuantumCircuit(qr, cr)
qc.h(qr[1])
qc.x(qr[2])
qc.x(qr[3])
qc.x(qr[4])
qc.cx(qr[1], qr[2])
qc.cx(qr[2], qr[3])
qc.cx(qr[3], qr[4])
qc.cx(qr[3], qr[14])
qc.measure(qr, cr)
qobj = transpiler.compile(qc, backend)
compiled_ops = qobj.experiments[0].instructions
for operation in compiled_ops:
if operation.name == 'cx':
self.assertIn(operation.qubits,
backend.configuration['coupling_map'])
def test_snapshot(self):
"""snapshot a bell state in the middle of circuit"""
basis_gates = ['cx', 'u1', 'u2', 'u3', 'snapshot']
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(2)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.snapshot('3')
circuit.cx(qr[0], qr[1])
circuit.h(qr[1])
sim = qiskit.providers.aer.StatevectorSimulator()
result = execute(circuit, sim, basis_gates=basis_gates).result()
# TODO: rely on Result.get_statevector() postprocessing rather than manual
snapshots = result.data(0)['snapshots']['statevector']['3']
snapshot = format_statevector(snapshots[0])
target = [0.70710678 + 0.j, 0. + 0.j, 0. + 0.j, 0.70710678 + 0.j]
fidelity = state_fidelity(snapshot, target)
self.assertGreater(
fidelity, self._desired_fidelity,
"snapshot has low fidelity{0:.2g}.".format(fidelity))
def test_mapping_already_satisfied(self):
"""Test compiler doesn't change circuit already matching backend coupling
"""
backend = FakeBackEnd()
q = qiskit.QuantumRegister(16)
c = qiskit.ClassicalRegister(16)
qc = qiskit.QuantumCircuit(q, c)
qc.h(q[1])
qc.x(q[2])
qc.x(q[3])
qc.x(q[4])
qc.cx(q[1], q[2])
qc.cx(q[2], q[3])
qc.cx(q[3], q[4])
qc.cx(q[3], q[14])
qc.measure(q, c)
qobj = transpiler.compile(qc, backend)
compiled_ops = qobj['circuits'][0]['compiled_circuit']['operations']
for op in compiled_ops:
if op['name'] == 'cx':
self.assertIn(op['qubits'],
backend.configuration['coupling_map'])
def test_average_data_dict_observable(self):
"""Test average_data for dictionary observable input"""
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qr, cr, name="qc")
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
shots = 10000
backend = BasicAer.get_backend('qasm_simulator')
result = qiskit.execute(qc, backend, shots=shots).result()
counts = result.get_counts(qc)
observable = {"00": 1, "11": 1, "01": -1, "10": -1}
mean_zz = average_data(counts=counts, observable=observable)
observable = {"00": 1, "11": -1, "01": 1, "10": -1}
mean_zi = average_data(counts, observable)
observable = {"00": 1, "11": -1, "01": -1, "10": 1}
mean_iz = average_data(counts, observable)
self.assertAlmostEqual(mean_zz, 1, places=1)
self.assertAlmostEqual(mean_zi, 0, places=1)
self.assertAlmostEqual(mean_iz, 0, places=1)
def run():
qr =qk.QuantumRegister(3)
cr = qk.ClassicalRegister(3)
qc= qk.QuantumCircuit(qr,cr)
#Creating the Hadamard State
qc.h(qr[0])
qc.h(qr[1])
# Circuit for I(theta) starts here
#qc.x(qr[0])
#qc.x(qr[1])
angles = [pi/2, 0, pi/2, 0]
#pi/4=0.7853
qc.cu3(angles[0],0,0,qr[0],qr[2])
qc.cx(qr[0],qr[1])
qc.cu3(-angles[0],0,0,qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.cu3(angles[0],0,0,qr[0],qr[2])
###
qc.barrier(qr)
qc.measure(qr,cr)
# In[41]:
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim, shots=10000)
result_sim = job_sim.result()
# In[42]:
counts = result_sim.get_counts(qc)
print(counts)
###
"""
def not_gate(input_bit):
q = qiskit.QuantumRegister(1) # a qubit to encode and manipulate the input
c = qiskit.ClassicalRegister(1) # a bit to store the output
qc = qiskit.QuantumCircuit(q, c)
# initialize the bit with respect to the input bit
if input_bit == '1':
qc.x(q[0])
# execute NOT
qc.x(0)
# extract output
qc.measure(q[0], c[0])
# run the circuit
job = qiskit.execute(qc, backend, shots=1)
output = list(job.result().get_counts().keys())[0]
return output
def test_execute_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Execute remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
backend = provider.available_backends({'simulator': True})[0]
qubit_reg = qiskit.QuantumRegister(2)
clbit_reg = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
job = execute(qc, backend)
results = job.result()
self.assertIsInstance(results, Result)
def t1_circuits(num_of_gates, gate_time, qubits):
"""
Generates circuit for T1 measurement.
Each circuit consists of an X gate, followed by a sequence of identity
gates.
Args:
num_of_gates (list of integers): the number of identity gates in each
circuit. Must be in an increasing
order.
gate_time (float): time of running a single gate.
qubits (list of integers): indices of the qubits whose T1 are
to be measured.
Returns:
A list of QuantumCircuit
xdata: a list of delay times
"""
xdata = gate_time * num_of_gates
qr = qiskit.QuantumRegister(max(qubits) + 1)
cr = qiskit.ClassicalRegister(len(qubits))
circuits = []
for circ_index, circ_length in enumerate(num_of_gates):
circ = qiskit.QuantumCircuit(qr, cr)
circ.name = 't1circuit_' + str(circ_index) + '_0'
for _, qubit in enumerate(qubits):
circ.x(qr[qubit])
circ = pad_id_gates(circ, qr, qubit, circ_length)
circ.barrier(qr)
for qind, qubit in enumerate(qubits):
circ.measure(qr[qubit], cr[qind])
circuits.append(circ)
return circuits, xdata
def test_noise(self):
"""turn on a pauli x noise for qubits 0 and 2"""
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.iden(qr[0])
circuit.noise(0)
circuit.iden(qr[1])
circuit.noise(1)
circuit.iden(qr[2])
circuit.measure(qr, cr)
config = {
'noise_params': {
'id': {'p_pauli': [1.0, 0.0, 0.0]}
}
}
sim = Aer.get_backend('qasm_simulator')
shots = 1000
result = execute(circuit, sim, config=config, shots=shots).result()
counts = result.get_counts()
target = {'101': shots}
self.assertEqual(counts, target)
def test_qasm(self, qe_token, qe_url):
"""counts from a GHZ state"""
qiskit.IBMQ.use_account(qe_token, qe_url)
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.measure(qr, cr)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
shots = 2000
result_cpp = execute(circuit, sim_cpp, shots=shots).result()
result_py = execute(circuit, sim_py, shots=shots).result()
result_ibmq = execute(circuit, sim_ibmq, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots*0.05)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots*0.05)
def test_to_qiskit_assign_qregs_and_cregs(qreg_sizes, measure, flip_creg):
nbits = sum(qreg_sizes)
cirq_circuit = cirq.testing.random_circuit(
nbits, n_moments=5, op_density=1, random_state=10
)
if measure:
cirq_circuit.append(cirq.measure_each(*cirq_circuit.all_qubits()))
qregs = [qiskit.QuantumRegister(s) for s in qreg_sizes]
cregs = [qiskit.ClassicalRegister(s) for s in qreg_sizes]
if flip_creg:
cregs = cregs[::-1]
qiskit_circuit = to_qiskit(cirq_circuit, qregs=qregs, cregs=cregs)
assert qiskit_circuit.qregs == qregs
assert qiskit_circuit.cregs == cregs
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(from_qiskit(qiskit_circuit)),
cirq.unitary(cirq_circuit),
atol=1e-5,
)
def test_qasm(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None):
"""counts from a GHZ state"""
register(QE_TOKEN, QE_URL, hub, group, project)
q = qiskit.QuantumRegister(3)
c = qiskit.ClassicalRegister(3)
circ = qiskit.QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.cx(q[1], q[2])
circ.measure(q, c)
sim_cpp = 'local_qasm_simulator_cpp'
sim_py = 'local_qasm_simulator_py'
sim_ibmq = 'ibmq_qasm_simulator'
shots = 2000
result_cpp = execute(circ, sim_cpp, shots=shots).result()
result_py = execute(circ, sim_py, shots=shots).result()
result_ibmq = execute(circ, sim_ibmq, shots=shots).result()
counts_cpp = result_cpp.get_counts()
counts_py = result_py.get_counts()
counts_ibmq = result_ibmq.get_counts()
self.assertDictAlmostEqual(counts_cpp, counts_py, shots * 0.05)
self.assertDictAlmostEqual(counts_py, counts_ibmq, shots * 0.05)
def test_compile_remote(self, QE_TOKEN, QE_URL):
"""Test Compiler remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL)
backend = lowest_pending_jobs(
provider.available_backends({
'local': False,
'simulator': False
}))
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = qiskit._compiler.compile(qc, backend)
# FIXME should test against the qobj when defined
self.assertEqual(len(qobj), 3)
def __init__(self, dag_circuit, parameters, initial_mapping):
"""
:param dag_circuit:
:param parameters:
:param initial_mapping:
"""
"""
The resulting circuit has a maximum number of qubits of the NISQ chip
"""
self.quantum_reg = qiskit.QuantumRegister(parameters["nisq_qubits"],
"q")
self.classic_reg = qiskit.ClassicalRegister(parameters["nisq_qubits"],
"c")
'''
Current logical qubit position on physical qubits
'''
"""
Returns an int-to-int map: logical qubit @ physical qubit map
There is something similar in Coupling, but I am not using it
"""
self.pos_circuit_to_phys = {}
for circ_qubit in range(dag_circuit.num_qubits()):
# configuration[i] = nrq - 1 - i # qubit i@i
self.pos_circuit_to_phys[circ_qubit] = initial_mapping[
circ_qubit] # qubit i@i
# print("current circ2phys: ", self.pos_circuit_to_phys)
"""
The reverse dictionary of current_positions
"""
self.pos_phys_to_circuit = {
k: -1
for k in range(parameters["nisq_qubits"])
}
for k, v in self.pos_circuit_to_phys.items():
self.pos_phys_to_circuit[v] = k
def to_qiskit(self):
"""Converts the circuit to a qiskit QuantumCircuit object."""
qiskit_circuit = qiskit.QuantumCircuit() # New qiskit circuit object
qreg = None
creg = None
if (
self.qubits != None and self.qubits != []
): # If there are qubits in the circuit, add them to the new qiskit circuit
max_qindex = max([q.index for q in self.qubits])
qreg = qiskit.QuantumRegister(max_qindex + 1, "q")
creg = qiskit.ClassicalRegister(max_qindex + 1, "c")
qiskit_circuit.add_register(qreg)
qiskit_circuit.add_register(creg)
if self.gates != None:
for gate in self.gates:
qiskit_gate_data = gate.to_qiskit(
qreg, creg
) # provide the gate conversion with the associated QuantumRegister
N = len(
qiskit_gate_data
) # total number of entries in the list (which is 3x the number of elementary gates)
if N % 3 != 0:
raise ValueError(
"The number of entries in qiskit_gate_data is {} which is not a multiple of 3".format(
N
)
)
for index in np.linspace(0, N - 3, N // 3):
qiskit_circuit.append(
qiskit_gate_data[int(index)],
qargs=qiskit_gate_data[int(index) + 1],
cargs=qiskit_gate_data[int(index) + 2],
)
return qiskit_circuit
def test_basic_reordering(self, qe_token, qe_url):
"""a simple reordering within a 2-qubit register"""
sim, real = self._get_backends(qe_token, qe_url)
if not sim or not real:
raise unittest.SkipTest('no remote device available')
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(2)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0], cr[1])
circuit.measure(qr[1], cr[0])
shots = 2000
qobj_real = compile(circuit, real)
qobj_sim = compile(circuit, sim)
result_real = real.run(qobj_real).result(timeout=600)
result_sim = sim.run(qobj_sim).result(timeout=600)
counts_real = result_real.get_counts()
counts_sim = result_sim.get_counts()
self.log.info(counts_real)
self.log.info(counts_sim)
threshold = 0.1 * shots
self.assertDictAlmostEqual(counts_real, counts_sim, threshold)
def tensored_calib_circ_creation():
"""
create tensored measurement calibration circuits and a GHZ state circuit for the tests
Returns:
QuantumCircuit: the tensored measurement calibration circuit
list[list[int]]: the mitigation pattern
QuantumCircuit: ghz circuit with 5 qubits (3 are used)
"""
mit_pattern = [[2], [4, 1]]
qr = qiskit.QuantumRegister(5)
# Generate the calibration circuits
meas_calibs, mit_pattern = tensored_meas_cal(mit_pattern, qr=qr)
cr = qiskit.ClassicalRegister(3)
ghz_circ = qiskit.QuantumCircuit(qr, cr)
ghz_circ.h(mit_pattern[0][0])
ghz_circ.cx(mit_pattern[0][0], mit_pattern[1][0])
ghz_circ.cx(mit_pattern[0][0], mit_pattern[1][1])
ghz_circ.measure(mit_pattern[0][0], cr[0])
ghz_circ.measure(mit_pattern[1][0], cr[1])
ghz_circ.measure(mit_pattern[1][1], cr[2])
return meas_calibs, mit_pattern, ghz_circ
def create_circuit_one_create(run_sequential_experiment=False,
list_of_cnots=[]):
qr = qiskit.QuantumRegister(14)
cr = qiskit.ClassicalRegister(14)
qc = qiskit.QuantumCircuit(qr, cr)
ones = [4, 5, 6, 11, 12, 13]
for q in ones:
qc.x(qr[q])
qc.barrier()
for gate in list_of_cnots:
qs = gate.replace("CX", "").split("_")
qc.cx(qr[int(qs[0])], qr[int(qs[1])])
if run_sequential_experiment:
qc.barrier()
qc.barrier()
# for i in [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13]:
for i in range(14):
qc.measure(qr[i], cr[i])
return qc
def task_1_2():
"""
Fitting of q2 to the random state in q1.
"""
n_qubits = 5
# Number of qubits per one state
n_qubit_state = int((n_qubits - 1) / 2)
# p1 = θ, p2 = ϕ, p3 = λ, p4 = θ, ...
u_params = get_u_params(n_qubits)
qreg_q = qk.QuantumRegister(n_qubits, 'q')
creg_c = qk.ClassicalRegister(1, 'c')
circuit = qk.QuantumCircuit(qreg_q, creg_c)
build_t2_circ(circuit, qreg_q, creg_c, n_qubit_state, u_params)
result = sciopt.differential_evolution(err,
bounds=[(0, 2 * np.pi)] * 3 *
int(n_qubits / 2),
args=(circuit, u_params),
maxiter=15)
tmp_circ = circuit.bind_parameters(
{u_params[i]: result.x[i]
for i in range(3 * int(n_qubits / 2))})
print('SWAP test after optimization: P(q0 = 0) = {}'.format(
swap_test(tmp_circ)))
print('Parameters of U3-gates:')
for i in range(n_qubit_state):
print('q{}: θ = {}, ϕ = {}, λ = {}'.format(i + n_qubit_state + 1,
result.x[3 * i],
result.x[3 * i + 1],
result.x[3 * i + 2]))
def append_measurements(circ, measurements):
""" Assumes creator returns an instance of the relevant circuit"""
num_classical = len(measurements.replace('1',''))
if num_classical > 0:
cr = qk.ClassicalRegister(num_classical, 'classical')
circ.add_register(cr)
ct_m = 0
ct_q = 0
for basis in measurements:
if basis == 'z':
circ.measure(ct_q, ct_m)
ct_m+=1
elif basis == 'x':
circ.u3(pi/2, 0, 0, ct_q)
circ.measure(ct_q, ct_m)
ct_m+=1
elif basis == 'y':
circ.u3(pi/2, -pi/2, -pi/2, ct_q)
circ.measure(ct_q, ct_m)
ct_m+=1
elif basis == '1':
pass
ct_q+=1
return circ
def test_execute_two_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test execute two remote.
If all correct some should exists.
"""
register(QE_TOKEN, QE_URL, hub, group, project)
backend = available_backends({'local': False, 'simulator': True})[0]
backend = get_backend(backend)
qubit_reg = qiskit.QuantumRegister(2)
clbit_reg = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc_extra.measure(qubit_reg, clbit_reg)
job = execute([qc, qc_extra], backend)
results = job.result()
self.assertIsInstance(results, Result)
def qv_circuits(qubit_lists=None, ntrials=1, qr=None, cr=None):
"""
Return a list of square quantum volume circuits (depth=width)
The qubit_lists is specified as a list of qubit lists. For each
set of qubits, circuits the depth as the number of qubits in the list
are generated
Args:
qubit_lists (list): list of list of qubits to apply qv circuits to. Assume
the list is ordered in increasing number of qubits
ntrials (int): number of random iterations
qr (QuantumRegister): quantum register to act on (if None one is created)
cr (ClassicalRegister): classical register to measure to (if None one is created)
Returns:
tuple: A tuple of the type (``circuits``, ``circuits_nomeas``) wheere:
``circuits`` is a list of lists of circuits for the qv sequences
(separate list for each trial) and `` circuitss_nomeas`` is the
same circuits but with no measurements for the ideal simulation
"""
circuits = [[] for e in range(ntrials)]
circuits_nomeas = [[] for e in range(ntrials)]
# get the largest qubit number out of all the lists (for setting the
# register)
depth_list = [len(l) for l in qubit_lists]
# go through for each trial
for trial in range(ntrials):
# go through for each depth in the depth list
for depthidx, depth in enumerate(depth_list):
n_q_max = np.max(qubit_lists[depthidx])
qr = qiskit.QuantumRegister(int(n_q_max + 1), 'qr')
qr2 = qiskit.QuantumRegister(int(depth), 'qr')
cr = qiskit.ClassicalRegister(int(depth), 'cr')
qc = qiskit.QuantumCircuit(qr, cr)
qc2 = qiskit.QuantumCircuit(qr2, cr)
qc.name = 'qv_depth_%d_trial_%d' % (depth, trial)
qc2.name = qc.name
# build the circuit
for _ in range(depth):
# Generate uniformly random permutation Pj of [0...n-1]
perm = np.random.permutation(depth)
# For each pair p in Pj, generate Haar random SU(4)
for k in range(int(np.floor(depth / 2))):
unitary = random_unitary(4)
pair = int(perm[2 * k]), int(perm[2 * k + 1])
qc.append(unitary, [
qr[qubit_lists[depthidx][pair[0]]],
qr[qubit_lists[depthidx][pair[1]]]
])
qc2.append(unitary, [qr2[pair[0]], qr2[pair[1]]])
# append an id to all the qubits in the ideal circuits
# to prevent a truncation error in the statevector
# simulators
qc2.u1(0, qr2)
circuits_nomeas[trial].append(qc2)
# add measurement
for qind, qubit in enumerate(qubit_lists[depthidx]):
qc.measure(qr[qubit], cr[qind])
circuits[trial].append(qc)
return circuits, circuits_nomeas
def __init__(self,
abstract_circuit: QCircuit,
variables,
qubit_map=None,
noise=None,
device=None,
*args,
**kwargs):
"""
Parameters
----------
abstract_circuit: QCircuit:
the circuit to be compiled to qiskit.
variables: dict:
variables to compile the circuit with
qubit_map: dictionary:
a qubit map which maps the abstract qubits in the abstract_circuit to the qubits on the backend
there is no need to initialize the corresponding backend types
the dictionary should simply be {int:int} (preferred) or {int:name}
if None the default will map to qubits 0 ... n_qubits -1 in the backend
noise:
noise to apply to the circuit.
device:
device on which to (perhaps, via emulation) execute the circuit.
args
kwargs
"""
self.op_lookup = {
'I': (lambda c: c.iden),
'X': (lambda c: c.x, lambda c: c.cx, lambda c: c.ccx),
'Y': (lambda c: c.y, lambda c: c.cy, lambda c: c.ccy),
'Z': (lambda c: c.z, lambda c: c.cz, lambda c: c.ccz),
'H': (lambda c: c.h, lambda c: c.ch, lambda c: c.cch),
'Rx': (lambda c: c.rx, lambda c: c.mcrx),
'Ry': (lambda c: c.ry, lambda c: c.mcry),
'Rz': (lambda c: c.rz, lambda c: c.mcrz),
'Phase': (lambda c: c.u1, lambda c: c.cu1),
'SWAP': (lambda c: c.swap, lambda c: c.cswap),
}
self.resolver = {}
self.tq_to_pars = {}
self.counter = 0
if qubit_map is None:
n_qubits = len(abstract_circuit.qubits)
else:
n_qubits = max(qubit_map.values()) + 1
self.q = qiskit.QuantumRegister(n_qubits, "q")
self.c = qiskit.ClassicalRegister(n_qubits, "c")
super().__init__(abstract_circuit=abstract_circuit,
variables=variables,
noise=noise,
device=device,
qubit_map=qubit_map,
*args,
**kwargs)
self.classical_map = self.make_classical_map(qubit_map=self.qubit_map)
if noise != None:
self.noise_lookup = {
'phase damp': qiskitnoise.phase_damping_error,
'amplitude damp': qiskitnoise.amplitude_damping_error,
'bit flip': get_bit_flip,
'phase flip': get_phase_flip,
'phase-amplitude damp':
qiskitnoise.phase_amplitude_damping_error,
'depolarizing': qiskitnoise.depolarizing_error
}
if isinstance(noise, str):
if noise == 'device':
if device is not None:
self.noise_model = qiskitnoise.NoiseModel.from_backend(
self.device)
else:
raise TequilaException(
'cannot get device noise without specifying a device!'
)
else:
raise TequilaException(
'The only allowed string for noise is \'device\'; recieved {}. Please try again!'
.format(str(noise)))
else:
nm = self.noise_model_converter(noise)
self.noise_model = nm
else:
self.noise_model = None
if len(self.tq_to_pars.keys()) is None:
self.pars_to_tq = None
self.resolver = None
else:
self.pars_to_tq = {v: k for k, v in self.tq_to_pars.items()}
self.resolver = {
k: to_float(v(variables))
for k, v in self.pars_to_tq.items()
}
'''
TOKEN = '4cb909509e365586e960d3b82179adee139035eae0c2c6f21b307e9b4bbb89e6339df2a481ae239a9eb3389530be03e2840e97edcde1de45f5da075bfdf553a4'
qk.IBMQ.save_account(TOKEN, overwrite=True)
qk.IBMQ.load_account()
'''
`n` is the number of Qubits needed to
generate a a random number between
0 and 2^n - 1
'''
n = 3
'''
Creating a Quantum Register with `n` Qubits and
`n` Classical Bits where n=3
'''
q = qk.QuantumRegister(n)
c = qk.ClassicalRegister(n)
qc = qk.QuantumCircuit(q, c)
'''
Applying a Hadamard Gate on the n Qubits
to get a final bitstring of size n
The bitstring will be converted to a
decimal number (integer) between 0 and 2^3 - 1 (7)
'''
for i in range(n):
qc.h(i)
qc.measure(q, c)
# The backend simulator available to me
backend = qk.IBMQ.get_provider().get_backend('ibmqx2')
new_job = qk.execute(qc, backend, shots=1)
