def load_unroll_qasm_file(filename, basis_gates='u1,u2,u3,cx,id'):
"""Load qasm file and return unrolled circuit
Args:
filename (str): a string for the filename including its location.
basis_gates (str): basis to unroll circuit to.
Returns:
Returns a unrolled QuantumCircuit object
"""
# create Program object Node (AST)
program_node_circuit = qasm.Qasm(filename=filename).parse()
unrolled_circuit = unroll.Unroller(
program_node_circuit, unroll.CircuitBackend(basis_gates.split(",")))
circuit_unrolled = unrolled_circuit.execute()
return circuit_unrolled
def setup(self, n_qubits, depth):
seed = 42
# NOTE: Remove the benchmarks larger than 20x2048 and 14x8192, this is
# a tradeoff for speed of benchmarking, creating circuits this size
# takes more time than is worth it for benchmarks that take a couple
# seconds
if n_qubits >= 20:
if depth >= 2048:
raise NotImplementedError
elif n_qubits == 14:
if depth > 2048:
raise NotImplementedError
self.qc = random_circuit(n_qubits, depth, measure=True,
conditional=True, seed=seed)
self.dag = converters.circuit_to_dag(self.qc)
self.qasm = qasm.Qasm(data=self.qc.qasm()).parse()
def __init__(self, compiled_circuit):
"""Initial the UnitarySimulator object."""
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=compiled_circuit).parse(),
unroll.SimulatorBackend(basis_gates))
unroller.backend.set_trace(False)
unroller.execute()
self.circuit = unroller.backend.circuit
self._number_of_qubits = self.circuit['number_of_qubits']
self.result = {}
self.result = {}
self.result['data'] = {}
self._unitary_state = np.identity(2**(self._number_of_qubits),
dtype=complex)
self._number_of_operations = self.circuit['number_of_operations']
def parse(file_path, verbose=False, prec=15):
"""
- file_path: Path to the OpenQASM file
- prec: Precision for the returned string
"""
qiskit_qasm = qasm.Qasm(file_path)
try:
qiskit_qasm.parse().qasm(prec)
return True
except qasm.QasmError as err:
if verbose:
print("Error:")
print(err)
return False
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
#strip measurements from circuit to avoid warnings
circuit['operations'] = [
op for op in circuit['operations'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it back to JSON
qobj = {
'id':
'unitary',
'config': {
'max_credits': None,
'shots': 1,
'backend': 'local_unitary_simulator'
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': self.qp.get_qasm('example'),
'config': {
'coupling_map': None,
'basis_gates': None,
'layout': None,
'seed': None
}
}]
}
# numpy.savetxt currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr, delimiter=',')
expected = np.loadtxt(
self._get_resource_path('example_unitary_matrix.dat'),
dtype='complex',
delimiter=',')
result = UnitarySimulator(qobj).run()
self.assertTrue(
np.allclose(result.get_data('test')['unitary'],
expected,
rtol=1e-3))
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
# strip measurements from circuit to avoid warnings
circuit['instructions'] = [
op for op in circuit['instructions'] if op['name'] != 'measure'
]
# the simulator is expecting a JSON format, so we need to convert it
# back to JSON
qobj = {
'id': 'unitary',
'config': {
'max_credits': None,
'shots': 1
},
'experiments': [circuit],
'header': {
'backend_name': 'local_unitary_simulator_py'
}
}
qobj = Qobj.from_dict(qobj)
qobj.experiments[0].header.name = 'test'
qobj.experiments[0].header.compiled_circuit_qasm = self.qp.get_qasm(
'example')
qobj.experiments[0].config = QobjItem(coupling_map=None,
basis_gates=None,
layout=None,
seed=None)
# numpy.savetxt currently prints complex numbers in a way
# loadtxt can't read. To save file do,
# fmtstr=['% .4g%+.4gj' for i in range(numCols)]
# np.savetxt('example_unitary_matrix.dat', numpyMatrix, fmt=fmtstr,
# delimiter=',')
expected = np.loadtxt(
self._get_resource_path('example_unitary_matrix.dat'),
dtype='complex',
delimiter=',')
result = UnitarySimulatorPy().run(qobj).result()
self.assertTrue(
np.allclose(result.get_unitary('test'), expected, rtol=1e-3))
def get_circuits(self, format_='dag'):
"""Get the compiled circuits generated.
Args:
format_ (str, optional): "qasm" | "qobj" | "QuantumCircuit"
Returns:
list: List of Compiled QuantumCircuit objects.
Raises:
NameError: if the output format is not valid.
"""
if format_ == 'qasm':
qasm_list = []
for circuit in self.circuit_list:
qasm_list.append(circuit.qasm())
return qasm_list
elif format_ == 'qobj':
json_list = []
for circuit in self.circuit_list:
node_circuit = qasm.Qasm(data=circuit.qasm()).parse()
unrolled_circuit = unroll.Unroller(
node_circuit, unroll.JsonBackend(self.basis_gates))
json_list.append(unrolled_circuit.execute())
return json_list
elif format_ == 'QuantumCircuit':
qc_list = []
for circuit in self.circuit_list:
qc_list.append(circuit)
# node_circuit = qasm.Qasm(data=circuit.qasm()).parse()
# unrolled_circuit = unroll.Unroller(
# node_circuit,
# unroll.CircuitBackend(self.basis_gates))
# qc_list.append(unrolled_circuit.execute())
return qc_list
# elif format is 'dag':
# qc_list = []
# for circuit in self.circuit_list:
# node_circuit = qasm.Qasm(data=circuit.qasm()).parse()
# unrolled_circuit = unroll.Unroller(
# node_circuit,
# unroll.DAGBackend(self.basis_gates))
# qc_list.append(unrolled_circuit.execute())
# return qc_list
else:
raise NameError(
'Unrecognized circuit output format: "{}"'.format(format_))
def compiler_function(dag_circuit, coupling_map=None, gate_costs=None):
"""
Modify a DAGCircuit based on a gate cost function.
Instructions:
Your submission involves filling in the implementation
of this function. The function takes as input a DAGCircuit
object, which can be generated from a QASM file by using the
function 'qasm_to_dag_circuit' from the included
'submission_evaluation.py' module. For more information
on the DAGCircuit object see the or QISKit documentation
(eg. 'help(DAGCircuit)').
Args:
dag_circuit (DAGCircuit): DAGCircuit object to be compiled.
coupling_circuit (list): Coupling map for device topology.
A coupling map of None corresponds an
all-to-all connected topology.
gate_costs (dict) : dictionary of gate names and costs.
Returns:
A modified DAGCircuit object that satisfies an input coupling_map
and has as low a gate_cost as possible.
"""
# I only modified the swap mapper
coupling = Coupling(coupling_map)
# Add swaps, so that we only use cnots that are allowed by the coupling map
compiled_dag = my_swap_mapper(deepcopy(dag_circuit),
coupling,
speedup=False)
# Expand swaps
basis_gates = "u1,u2,u3,cx,id" # QE target basis
program_node_circuit = qasm.Qasm(data=compiled_dag.qasm()).parse()
unroller_circuit = unroll.Unroller(
program_node_circuit, unroll.DAGBackend(basis_gates.split(",")))
compiled_dag = unroller_circuit.execute()
# Change cx directions
compiled_dag = direction_mapper(compiled_dag, coupling)
# Simplify cx gates
cx_cancellation(compiled_dag)
# Simplify single qubit gates
compiled_dag = optimize_1q_gates(compiled_dag)
# Return the compiled dag circuit
return compiled_dag
def setUp(self):
self.qp = None
self.seed = 88
qasm_filename = self._get_resource_path('qasm/example.qasm')
unroller = unroll.Unroller(
qasm.Qasm(filename=qasm_filename).parse(), unroll.JsonBackend([]))
circuit = QobjExperiment.from_dict(unroller.execute())
circuit.config = QobjItem(coupling_map=None,
basis_gates='u1,u2,u3,cx,id',
layout=None,
seed=self.seed)
circuit.header.name = 'test'
self.qobj = Qobj(
id='test_sim_single_shot',
config=QobjConfig(shots=1024, memory_slots=6, max_credits=3),
experiments=[circuit],
header=QobjHeader(backend_name='local_qasm_simulator_py'))
def __init__(self, compiled_circuit, shots, seed=random.random()):
"""Initialize the QasmSimulator object."""
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=compiled_circuit).parse(),
unroll.SimulatorBackend(basis_gates))
unroller.backend.set_trace(False)
unroller.execute()
self.circuit = unroller.backend.circuit
self._number_of_qubits = self.circuit['number_of_qubits']
self._number_of_cbits = self.circuit['number_of_cbits']
self.result = {}
self.result['data'] = {}
self._quantum_state = 0
self._classical_state = 0
self._shots = shots
random.seed(seed)
self._number_of_operations = self.circuit['number_of_operations']
def setUp(self):
self.seed = 88
self.qasmFileName = os.path.join(qiskit.__path__[0],
'../test/python/qasm/example.qasm')
self.qp = QuantumProgram()
shots = 1
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
self.job = {
'compiled_circuit': circuit,
'config': {
'shots': shots,
'seed': random.randint(0, 10)
}
}
def _unroller_code(qasm_circuit, basis_gates=None):
""" Unroll the code.
Circuit is the circuit to unroll using the DAG representation.
This is an internal function.
Args:
qasm_circuit (str): a circuit representation as qasm text.
basis_gates (str): a comma seperated string and are the base gates,
which by default are: u1,u2,u3,cx,id
Return:
object: a dag representation of the circuit unrolled to basis gates
"""
if not basis_gates:
basis_gates = "u1,u2,u3,cx,id" # QE target basis
program_node_circuit = qasm.Qasm(data=qasm_circuit).parse()
unroller_circuit = unroll.Unroller(
program_node_circuit, unroll.DAGBackend(basis_gates.split(",")))
dag_circuit_unrolled = unroller_circuit.execute()
return dag_circuit_unrolled
def test_dag_to_dag_expand_gates_custom_basis(self):
"""Test DagUnroller.expand_gates() to a gate basis."""
ast = qasm.Qasm(
filename=self._get_resource_path('qasm/example.qasm')).parse()
dag_circuit = Unroller(ast, DAGBackend()).execute()
dag_unroller = DagUnroller(dag_circuit, DAGBackend())
expanded_dag_circuit = dag_unroller.expand_gates(
basis=["cx", "u1", "u2", "u3"])
expected_result = """\
OPENQASM 2.0;
qreg q[3];
qreg r[3];
creg c[3];
creg d[3];
gate u2(phi,lambda) q
{
U((pi/2),phi,lambda) q;
}
gate h a
{
u2(0,pi) a;
}
gate cx c,t
{
CX c,t;
}
u2(0,pi) q[2];
cx q[2],r[2];
measure r[2] -> d[2];
u2(0,pi) q[1];
cx q[1],r[1];
measure r[1] -> d[1];
u2(0,pi) q[0];
cx q[0],r[0];
barrier q[0],q[1],q[2];
measure q[0] -> c[0];
measure q[1] -> c[1];
measure q[2] -> c[2];
measure r[0] -> d[0];
"""
self.assertEqual(expanded_dag_circuit.qasm(), expected_result)
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
with open(self.qasm_filename, 'r') as qasm_file:
self.qasm_text = qasm_file.read()
self.qasm_ast = qasm.Qasm(data=self.qasm_text).parse()
self.qasm_be = unroll.CircuitBackend(
['u1', 'u2', 'u3', 'id', 'cx'])
self.qasm_circ = unroll.Unroller(self.qasm_ast,
self.qasm_be).execute()
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(2, 'c')
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.measure(qr[0], cr[0])
self.qc = qc
# create qobj
compiled_circuit1 = QobjExperiment.from_dict(
transpile_dag(DAGCircuit.fromQuantumCircuit(self.qc),
format='json'))
compiled_circuit2 = QobjExperiment.from_dict(
transpile_dag(DAGCircuit.fromQuantumCircuit(self.qasm_circ),
format='json'))
self.qobj = Qobj(qobj_id='test_qobj',
config=QobjConfig(shots=2000,
memory_slots=1,
max_credits=3,
seed=1111),
experiments=[compiled_circuit1, compiled_circuit2],
header=QobjHeader(backend_name='qasm_simulator'))
self.qobj.experiments[0].header.name = 'test_circuit1'
self.qobj.experiments[0].config = QobjItem(
basis_gates='u1,u2,u3,cx,id')
self.qobj.experiments[1].header.name = 'test_circuit2'
self.qobj.experiments[1].config = QobjItem(
basis_gates='u1,u2,u3,cx,id')
self.backend = QasmSimulator()
def setUp(self):
self.seed = 88
self.qasm_filename = self._get_resource_path('qasm/example.qasm')
self.qp = QuantumProgram()
self.qp.load_qasm_file(self.qasm_filename, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm('example')).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
circuit_config = {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': self.seed
}
resources = {'max_credits': 3}
self.qobj = {
'id':
'test_sim_single_shot',
'config': {
'max_credits': resources['max_credits'],
'shots': 1024,
'backend_name': 'local_qasm_simulator_py',
},
'circuits': [{
'name': 'test',
'compiled_circuit': circuit,
'compiled_circuit_qasm': None,
'config': circuit_config
}]
}
self.q_job = QuantumJob(self.qobj,
backend=QasmSimulatorPy(),
circuit_config=circuit_config,
seed=self.seed,
resources=resources,
preformatted=True)
def test_if_statement(self):
logging.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])
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=qp.get_qasm('test_if')).parse(),
unroll.JsonBackend(basis_gates))
ucircuit = json.loads(unroller.execute())
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': json.dumps(ucircuit), 'config': config}
result_if_true = QasmSimulator(job).run()
del ucircuit['operations'][1] # remove x(qr[1]) operation
job = {'compiled_circuit': json.dumps(ucircuit), 'config': config}
result_if_false = QasmSimulator(job).run()
logging.info('result_if_true circuit:')
logging.info(circuit.qasm())
logging.info('result_if_true={0}'.format(result_if_true))
del circuit.data[1]
logging.info('result_if_false circuit:')
logging.info(circuit.qasm())
logging.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_qasm_simulator(self):
"""Test data counts output for single circuit run against reference."""
shots = 1024
self.qp.load_qasm_file(self.qasmFileName, name='example')
basis_gates = [] # unroll to base gates
unroller = unroll.Unroller(
qasm.Qasm(data=self.qp.get_qasm("example")).parse(),
unroll.JsonBackend(basis_gates))
circuit = unroller.execute()
config = {'shots': shots, 'seed': self.seed}
job = {'compiled_circuit': circuit, 'config': config}
result = QasmSimulator(job).run()
expected = {
'100 100': 137,
'011 011': 131,
'101 101': 117,
'111 111': 127,
'000 000': 131,
'010 010': 141,
'110 110': 116,
'001 001': 124
}
self.assertEqual(result['data']['counts'], expected)
def dag2json(dag_circuit, basis_gates='u1,u2,u3,cx,id'):
"""Make a Json representation of the circuit.
Takes a circuit dag and returns json circuit obj. This is an internal
function.
Args:
dag_ciruit (dag object): a dag representation of the circuit.
basis_gates (str): a comma seperated string and are the base gates,
which by default are: u1,u2,u3,cx,id
Returns:
the json version of the dag
"""
# TODO: Jay: I think this needs to become a method like .qasm() for the DAG.
try:
circuit_string = dag_circuit.qasm(qeflag=True)
except TypeError:
circuit_string = dag_circuit.qasm()
unroller = unroll.Unroller(qasm.Qasm(data=circuit_string).parse(),
unroll.JsonBackend(basis_gates.split(",")))
json_circuit = unroller.execute()
return json_circuit
def test_if_statement(self):
self.log.info('test_if_statement_x')
shots = 100
max_qubits = 3
qr = QuantumRegister(max_qubits, 'qr')
cr = ClassicalRegister(max_qubits, 'cr')
circuit_if_true = QuantumCircuit(qr, cr, name='test_if_true')
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 = QuantumCircuit(qr, cr, name='test_if_false')
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=circuit_if_true.qasm()).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_true = QobjExperiment.from_dict(unroller.execute())
unroller = unroll.Unroller(
qasm.Qasm(data=circuit_if_false.qasm()).parse(),
unroll.JsonBackend(basis_gates))
ucircuit_false = QobjExperiment.from_dict(unroller.execute())
# Customize the experiments and create the qobj.
ucircuit_true.config = QobjItem(coupling_map=None,
basis_gates='u1,u2,u3,cx,id',
layout=None,
seed=None)
ucircuit_true.header.name = 'test_if_true'
ucircuit_false.config = QobjItem(coupling_map=None,
basis_gates='u1,u2,u3,cx,id',
layout=None,
seed=None)
ucircuit_false.header.name = 'test_if_false'
qobj = Qobj(id='test_if_qobj',
config=QobjConfig(max_credits=3,
shots=shots,
memory_slots=max_qubits),
experiments=[ucircuit_true, ucircuit_false],
header=QobjHeader(backend_name='local_qasm_simulator_py'))
result = QasmSimulatorPy().run(qobj).result()
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=%s', 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=%s', result_if_false)
self.assertTrue(result_if_true['counts']['111'] == 100)
self.assertTrue(result_if_false['counts']['001'] == 100)
def test_from_dag_to_json_with_basis(self):
ast = qasm.Qasm(
filename=self._get_resource_path('qasm/example.qasm')).parse()
dag_circuit = Unroller(ast, DAGBackend(["cx", "u1", "u2",
"u3"])).execute()
dag_unroller = DagUnroller(dag_circuit,
JsonBackend(["cx", "u1", "u2", "u3"]))
json_circuit = dag_unroller.execute()
expected_result = {
'operations': [{
'qubits': [5],
'texparams': ['0', '\\pi'],
'params': [0.0, 3.141592653589793],
'name': 'u2'
}, {
'qubits': [5, 2],
'texparams': [],
'params': [],
'name': 'cx'
}, {
'qubits': [2],
'clbits': [2],
'name': 'measure'
}, {
'qubits': [4],
'texparams': ['0', '\\pi'],
'params': [0.0, 3.141592653589793],
'name': 'u2'
}, {
'qubits': [4, 1],
'texparams': [],
'params': [],
'name': 'cx'
}, {
'qubits': [1],
'clbits': [1],
'name': 'measure'
}, {
'qubits': [3],
'texparams': ['0', '\\pi'],
'params': [0.0, 3.141592653589793],
'name': 'u2'
}, {
'qubits': [3, 0],
'texparams': [],
'params': [],
'name': 'cx'
}, {
'qubits': [3, 4, 5],
'name': 'barrier'
}, {
'qubits': [5],
'clbits': [5],
'name': 'measure'
}, {
'qubits': [4],
'clbits': [4],
'name': 'measure'
}, {
'qubits': [3],
'clbits': [3],
'name': 'measure'
}, {
'qubits': [0],
'clbits': [0],
'name': 'measure'
}],
'header': {
'clbit_labels': [['d', 3], ['c', 3]],
'number_of_qubits':
6,
'qubit_labels': [['r', 0], ['r', 1], ['r', 2], ['q', 0],
['q', 1], ['q', 2]],
'number_of_clbits':
6
}
}
self.assertEqual(json_circuit, expected_result)
def test_from_dag_to_json(self):
ast = qasm.Qasm(
filename=self._get_resource_path('qasm/example.qasm')).parse()
dag_circuit = Unroller(ast, DAGBackend()).execute()
dag_unroller = DagUnroller(dag_circuit, JsonBackend())
json_circuit = dag_unroller.execute()
expected_result = {
'operations': [{
'qubits': [5],
'texparams': ['0.5 \\pi', '0', '\\pi'],
'name':
'U',
'params': [1.5707963267948966, 0.0, 3.141592653589793]
}, {
'name': 'CX',
'qubits': [5, 2]
}, {
'clbits': [2],
'name': 'measure',
'qubits': [2]
}, {
'qubits': [4],
'texparams': ['0.5 \\pi', '0', '\\pi'],
'name':
'U',
'params': [1.5707963267948966, 0.0, 3.141592653589793]
}, {
'name': 'CX',
'qubits': [4, 1]
}, {
'clbits': [1],
'name': 'measure',
'qubits': [1]
}, {
'qubits': [3],
'texparams': ['0.5 \\pi', '0', '\\pi'],
'name':
'U',
'params': [1.5707963267948966, 0.0, 3.141592653589793]
}, {
'name': 'CX',
'qubits': [3, 0]
}, {
'name': 'barrier',
'qubits': [3, 4, 5]
}, {
'clbits': [5],
'name': 'measure',
'qubits': [5]
}, {
'clbits': [4],
'name': 'measure',
'qubits': [4]
}, {
'clbits': [3],
'name': 'measure',
'qubits': [3]
}, {
'clbits': [0],
'name': 'measure',
'qubits': [0]
}],
'header': {
'number_of_clbits':
6,
'qubit_labels': [['r', 0], ['r', 1], ['r', 2], ['q', 0],
['q', 1], ['q', 2]],
'number_of_qubits':
6,
'clbit_labels': [['d', 3], ['c', 3]]
}
}
self.assertEqual(json_circuit, expected_result)
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()
qobj = {
'id':
'test_if_qobj',
'config': {
'max_credits': 3,
'shots': shots,
'backend_name': 'local_qasm_simulator_py',
},
'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, backend=QasmSimulatorPy(), preformatted=True)
result = QasmSimulatorPy().run(q_job).result()
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=%s', 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=%s', result_if_false)
self.assertTrue(result_if_true['counts']['111'] == 100)
self.assertTrue(result_if_false['counts']['001'] == 100)
def compiler_function(dag_circuit, coupling_map=None, gate_costs=None):
"""
Modify a DAGCircuit based on a gate cost function.
Instructions:
Your submission involves filling in the implementation
of this function. The function takes as input a DAGCircuit
object, which can be generated from a QASM file by using the
function 'qasm_to_dag_circuit' from the included
'submission_evaluation.py' module. For more information
on the DAGCircuit object see the or QISKit documentation
(eg. 'help(DAGCircuit)').
Args:
dag_circuit (DAGCircuit): DAGCircuit object to be compiled.
coupling_circuit (list): Coupling map for device topology.
A coupling map of None corresponds an
all-to-all connected topology.
gate_costs (dict) : dictionary of gate names and costs.
Returns:
A modified DAGCircuit object that satisfies an input coupling_map
and has as low a gate_cost as possible.
"""
qasm_in = dag_circuit.qasm()
Q_program = QuantumProgram()
qcircuit_name = Q_program.load_qasm_text(qasm_in)
qcircuit = Q_program.get_circuit(qcircuit_name)
tuple_map = {}
if coupling_map is None:
# todo: make all-to-all map
raise ValueError
else:
for key in coupling_map.keys():
tuple_map[key] = tuple(coupling_map[key])
result, cost = Embed(qcircuit, tuple_map)
compiled_dag = DAGCircuit.fromQuantumCircuit(result)
return compiled_dag
if False:
# Example using mapper passes in Qiskit
import copy
from qiskit.mapper import swap_mapper, direction_mapper, cx_cancellation, optimize_1q_gates, Coupling
from qiskit import qasm, unroll
initial_layout = None
coupling = Coupling(coupling_map)
compiled_dag, final_layout = swap_mapper(copy.deepcopy(dag_circuit),
coupling,
initial_layout,
trials=40,
seed=19)
# Expand swaps
basis_gates = "u1,u2,u3,cx,id" # QE target basis
program_node_circuit = qasm.Qasm(data=compiled_dag.qasm()).parse()
unroller_circuit = unroll.Unroller(
program_node_circuit, unroll.DAGBackend(basis_gates.split(",")))
compiled_dag = unroller_circuit.execute()
# Change cx directions
compiled_dag = direction_mapper(compiled_dag, coupling)
# Simplify cx gates
cx_cancellation(compiled_dag)
# Simplify single qubit gates
compiled_dag = optimize_1q_gates(compiled_dag)
# Return the compiled dag circuit
return compiled_dag
