def test_yzy_zyz_cases(self):
"""Test mapper function yzy_to_zyz works in previously failed cases.
See: https://github.com/QISKit/qiskit-terra/issues/607
"""
backend = FakeQX4BackEnd()
circ1 = load_qasm_string(yzy_zyz_1)
qobj1 = qiskit.wrapper.compile(circ1, backend)
self.assertIsInstance(qobj1, Qobj)
circ2 = load_qasm_string(yzy_zyz_2)
qobj2 = qiskit.wrapper.compile(circ2, backend)
self.assertIsInstance(qobj2, Qobj)
def test_output_unitary_same_as_qiskit():
qubits = tuple(_make_qubits(5))
operations = _all_operations(*qubits, include_measurements=False)
output = cirq.QasmOutput(operations,
qubits,
header='Generated from Cirq',
precision=10)
text = str(output)
# coverage: ignore
try:
# We don't want to require qiskit as a dependency but
# if Qiskit is installed, test QASM output against it.
import qiskit # type: ignore
except ImportError:
return
circuit = cirq.Circuit.from_ops(operations)
cirq_unitary = circuit.unitary(qubit_order=qubits)
result = qiskit.execute(
qiskit.load_qasm_string(text),
backend=qiskit.Aer.get_backend('unitary_simulator'))
qiskit_unitary = result.result().get_unitary()
qiskit_unitary = _reorder_indices_of_matrix(
qiskit_unitary, list(reversed(range(len(qubits)))))
cirq.testing.assert_allclose_up_to_global_phase(cirq_unitary,
qiskit_unitary,
rtol=1e-8,
atol=1e-8)
def _qasm_runner_qiskit(qasm, qiskit_backend, shots=None, returns=None, **kwargs):
if returns is None:
returns = "shots"
elif returns not in ("shots", "_exception", "qiskit_result"):
raise ValueError("`returns` shall be None, 'shots', 'qiskit_result' or '_exception'")
import_error = None
try:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
from qiskit import load_qasm_string, execute
except Exception as e:
import_error = e
if import_error:
if returns == "_exception":
return e
if isinstance(import_error, ImportError):
raise ImportError("Cannot import qiskit. To use this backend, please install qiskit." +
" `pip install qiskit`.")
else:
raise ValueError("Unknown error raised when importing qiskit. To get exception, " +
'run this backend with arg `returns="_exception"`')
else:
if shots is None:
shots = 1024
qk_circuit = load_qasm_string(qasm)
result = execute(qk_circuit, backend=qiskit_backend, shots=shots, **kwargs).result()
if returns == "qiskit_result":
return result
counts = Counter({bits[::-1]: val for bits, val in result.get_counts().items()})
return counts
def sampling(circuit, meas):
meas = tuple(meas)
if not meas:
return {}
circuit.measure[meas]
qasm = circuit.to_qasm()
qk_circuit = qiskit.load_qasm_string(qasm)
result = qiskit.execute(qk_circuit, backend, **execute_kwargs).result()
counts = Counter({reduce_bits(bits, meas): val for bits, val in result.get_counts().items()})
return {k: v / shots for k, v in counts.items()}
def circuit_drawer(circuit, filename, directory=None):
"""Saves circuit to pdf
Parameters:
circuit (QuantumCircuit, DAGCircuit, Qasm): input circuit, better in Qasm format
filename (str): filename to write pdf, file extension not needed
directory (str): directory where the circuit will be saved
"""
if isinstance(circuit, DAGCircuit):
circuit = load_qasm_string(circuit.qasm())
elif isinstance(circuit, str):
circuit = load_qasm_string(circuit)
elif isinstance(circuit, Qasm):
circuit = load_qasm_string(circuit.parse())
if directory is None:
directory = ''
generate_latex_source(circuit,
directory + filename + '.tex',
basis="id,u0,u1,u2,u3,x,y,z,h,s,sdg,t,tdg,rx,ry,rz,"
"cx,cy,cz,ch,crz,cu1,cu3,swap,ccx,cswap",
scale=0.8)
if directory == '':
cmd = ['pdflatex', '-interaction', 'nonstopmode', '%s.tex' % filename]
else:
cmd = [
'pdflatex', '-interaction', 'nonstopmode', '-output-directory',
directory,
'%s.tex' % filename
]
proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL)
proc.communicate()
retcode = proc.returncode
if not retcode == 0:
raise ValueError('Error {} executing command: {}'.format(
retcode, ' '.join(cmd)))
os.unlink('%s.log' % (directory + filename))
os.unlink('%s.toc' % (directory + filename))
os.unlink('%s.snm' % (directory + filename))
os.unlink('%s.nav' % (directory + filename))
os.unlink('%s.aux' % (directory + filename))
def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):
# coverage: ignore
try:
# We don't want to require qiskit as a dependency but
# if Qiskit is installed, test QASM output against it.
import qiskit # type: ignore
except ImportError:
return
num_qubits = int(np.log2(len(unitary)))
result = qiskit.execute(
qiskit.load_qasm_string(qasm),
backend=qiskit.Aer.get_backend('unitary_simulator'))
qiskit_unitary = result.result().get_unitary()
qiskit_unitary = _reorder_indices_of_matrix(
qiskit_unitary, list(reversed(range(num_qubits))))
lin_alg_utils.assert_allclose_up_to_global_phase(unitary,
qiskit_unitary,
rtol=1e-8,
atol=1e-8)
def assert_qasm_is_consistent_with_unitary(val: Any):
"""Uses `val._unitary_` to check `val._qasm_`'s behavior."""
# Only test if qiskit is installed.
try:
import qiskit
except ImportError:
# coverage: ignore
warnings.warn("Skipped assert_qasm_is_consistent_with_unitary because "
"qiskit isn't installed to verify against.")
return
unitary = protocols.unitary(val, None)
if unitary is None:
# Vacuous consistency.
return
controls = getattr(val, 'control_qubits', None)
if controls is None:
qubit_count = len(unitary).bit_length() - 1
else:
qubit_count = len(unitary).bit_length() - 1 - (len(controls) -
controls.count(None))
if isinstance(val, ops.Operation):
qubits = val.qubits
op = val
elif isinstance(val, ops.Gate):
qubits = tuple(line.LineQubit.range(qubit_count))
op = val.on(*qubits)
else:
raise NotImplementedError("Don't know how to test {!r}".format(val))
args = protocols.QasmArgs(
qubit_id_map={q: 'q[{}]'.format(i)
for i, q in enumerate(qubits)})
qasm = protocols.qasm(op, args=args, default=None)
if qasm is None:
return
header = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[{}];
""".format(len(qubits))
qasm = header + qasm
qasm_unitary = None
try:
result = qiskit.execute(
qiskit.load_qasm_string(qasm),
backend=qiskit.Aer.get_backend('unitary_simulator'))
qasm_unitary = result.result().get_unitary()
qasm_unitary = _reorder_indices_of_matrix(
qasm_unitary, list(reversed(range(len(qubits)))))
lin_alg_utils.assert_allclose_up_to_global_phase(qasm_unitary,
unitary,
rtol=1e-8,
atol=1e-8)
except Exception as ex:
if qasm_unitary is not None:
p_unitary, p_qasm_unitary = linalg.match_global_phase(
unitary, qasm_unitary)
else:
p_unitary = None
p_qasm_unitary = None
raise AssertionError(
'QASM be consistent with cirq.unitary(op) up to global phase.\n\n'
'op:\n{}\n\n'
'cirq.unitary(op):\n{}\n\n'
'Generated QASM:\n\n{}\n\n'
'Unitary of generated QASM:\n{}\n\n'
'Phased matched cirq.unitary(op):\n{}\n\n'
'Phased matched unitary of generated QASM:\n{}\n\n'
'Underlying error:\n{}'.format(_indent(repr(op)),
_indent(repr(unitary)),
_indent(qasm),
_indent(repr(qasm_unitary)),
_indent(repr(p_unitary)),
_indent(repr(p_qasm_unitary)),
_indent(str(ex))))
def assert_qasm_is_consistent_with_unitary(val: Any):
"""Uses `val._unitary_` to check `val._qasm_`'s behavior."""
# Only test if qiskit is installed.
try:
import qiskit
except ImportError:
# coverage: ignore
warnings.warn("Skipped assert_qasm_is_consistent_with_unitary because "
"qiskit isn't installed to verify against.")
return
unitary = protocols.unitary(val, None)
if unitary is None:
# Vacuous consistency.
return
qubit_count = len(unitary).bit_length() - 1
if isinstance(val, ops.Operation):
qubits = val.qubits
op = val
elif isinstance(val, ops.Gate):
qubits = tuple(line.LineQubit.range(qubit_count))
op = val.on(*qubits)
else:
raise NotImplementedError("Don't know how to test {!r}".format(val))
qasm = str(circuits.QasmOutput(op, qubits[::-1], precision=10))
qasm_unitary = None
try:
result = qiskit.execute(
qiskit.load_qasm_string(qasm),
backend=qiskit.Aer.get_backend('unitary_simulator'))
qasm_unitary = result.result().get_unitary()
lin_alg_utils.assert_allclose_up_to_global_phase(
qasm_unitary,
unitary,
rtol=1e-8,
atol=1e-8)
except Exception as ex:
if qasm_unitary is not None:
p_unitary, p_qasm_unitary = linalg.match_global_phase(
unitary, qasm_unitary)
else:
p_unitary = None
p_qasm_unitary = None
raise AssertionError(
'QASM be consistent with cirq.unitary(op) up to global phase.\n\n'
'op:\n{}\n\n'
'cirq.unitary(op):\n{}\n\n'
'Generated QASM:\n\n{}\n\n'
'Unitary of generated QASM:\n{}\n\n'
'Phased matched cirq.unitary(op):\n{}\n\n'
'Phased matched unitary of generated QASM:\n{}\n\n'
'Underlying error:\n{}'.format(
_indent(repr(op)),
_indent(repr(unitary)),
_indent(qasm),
_indent(repr(qasm_unitary)),
_indent(repr(p_unitary)),
_indent(repr(p_qasm_unitary)),
_indent(str(ex))))
# 0. build circuit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
circ = QuantumCircuit(q, c)
circ.cx(q[0], q[1])
circ.cx(q[0], q[1])
circ.cx(q[0], q[1])
circ.cx(q[0], q[1])
circ.measure(q, c)
# draw circuit
from qiskit.tools.visualization import plot_circuit
plot_circuit(circ)
# 1. standard compile -- standard qiskit passes, when no PassManager given
from qiskit import transpiler, load_qasm_string
qobj_standard = transpiler.compile(circ, backend_device)
compiled_standard = load_qasm_string(
qobj_standard['circuits'][0]['compiled_circuit_qasm'])
plot_circuit(compiled_standard)
# 2. custom compile -- customize PassManager to run specific circuit transformations
from qiskit.transpiler.passes import CXCancellation
pm = transpiler.PassManager()
pm.add_pass(CXCancellation())
qobj_custom = transpiler.compile(circ, backend_device, pass_manager=pm)
compiled_custom = load_qasm_string(
qobj_custom['circuits'][0]['compiled_circuit_qasm'])
plot_circuit(compiled_custom)
def get_circuit(code):
if qiskit.__version__ == '0.6.1': # My dev env has a different version...
c = qiskit.load_qasm_string(code)
else:
c = qiskit.QuantumCircuit.from_qasm_str(code)
return c
