def test_circuit_multi(self):
"""Test circuit multi regs declared at start."""
qreg0 = QuantumRegister(2, 'q0')
creg0 = ClassicalRegister(2, 'c0')
qreg1 = QuantumRegister(2, 'q1')
creg1 = ClassicalRegister(2, 'c1')
circ = QuantumCircuit(qreg0, qreg1)
circ.x(qreg0[1])
circ.x(qreg1[0])
meas = QuantumCircuit(qreg0, qreg1, creg0, creg1)
meas.measure(qreg0, creg0)
meas.measure(qreg1, creg1)
qc = circ + meas
backend_sim = BasicAer.get_backend('qasm_simulator')
result = execute(qc, backend_sim, seed_transpiler=34342).result()
counts = result.get_counts(qc)
target = {'01 10': 1024}
backend_sim = BasicAer.get_backend('statevector_simulator')
result = execute(circ, backend_sim, seed_transpiler=3438).result()
state = result.get_statevector(circ)
backend_sim = BasicAer.get_backend('unitary_simulator')
result = execute(circ, backend_sim, seed_transpiler=3438).result()
unitary = result.get_unitary(circ)
self.assertEqual(counts, target)
self.assertAlmostEqual(state_fidelity(Statevector.from_label('0110'),
state),
1.0,
places=7)
self.assertAlmostEqual(process_fidelity(Operator.from_label('IXXI'),
unitary),
1.0,
places=7)
def test_plugin_configuration(self):
"""Tests plugin with a custom configuration."""
config = {
"network_layout": "sequ",
"connectivity_type": "full",
"depth": 0,
"seed": 12345,
"optimizer": SLSQP(),
}
transpiler_pass = UnitarySynthesis(
basis_gates=["rx", "ry", "rz", "cx"],
method="aqc",
plugin_config=config)
dag = circuit_to_dag(self._qc)
dag = transpiler_pass.run(dag)
approx_circuit = dag_to_circuit(dag)
approx_unitary = Operator(approx_circuit).data
np.testing.assert_array_almost_equal(self._target_unitary,
approx_unitary, 3)
def _fidelity_result(evals, evecs, target, qpt=False):
"""Faster computation of fidelity from eigen decomposition"""
# Format target to statevector or densitymatrix array
trace = np.sqrt(len(evals)) if qpt else 1
name = "process_fidelity" if qpt else "state_fidelity"
if target is None:
raise AnalysisError("No target state provided")
if isinstance(target, QuantumChannel):
target_state = Choi(target).data / trace
elif isinstance(target, BaseOperator):
target_state = np.ravel(Operator(target), order="F") / np.sqrt(trace)
else:
target_state = np.array(target)
if target_state.ndim == 1:
rho = evecs @ (evals / trace * evecs).T.conj()
fidelity = np.real(target_state.conj() @ rho @ target_state)
else:
sqrt_rho = evecs @ (np.sqrt(evals / trace) * evecs).T.conj()
eig = la.eigvalsh(sqrt_rho @ target_state @ sqrt_rho)
fidelity = np.sum(np.sqrt(np.maximum(eig, 0))) ** 2
return AnalysisResultData(name, fidelity)
def __init__(self):
# Initialize Registers
self.code = QuantumRegister(5, name="code")
self.syndrm = QuantumRegister(4, name="syndrome")
# Build Circuit Components
self.encoder_ckt = self.build_encoder()
self.syndrome_ckt = self.build_syndrome()
self.correction_ckt = self.build_correction()
self.decoder_ckt = self.encoder_ckt.mirror()
# Build Noisy Channel
self.noise_ckt = QuantumCircuit(self.code, self.syndrm)
for i in range(5):
self.noise_ckt.unitary(Operator(np.eye(2)), [self.code[i]],
label='noise')
# Compose Full Circuit
circ = QuantumCircuit(self.code, self.syndrm)
circ.barrier()
self.circuit = self.encoder_ckt + circ + self.noise_ckt + circ + self.syndrome_ckt
self.circuit = self.circuit + circ + self.correction_ckt + circ + self.decoder_ckt
def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
r"""Return controlled version of gate
Args:
num_ctrl_qubits (int): number of controls to add to gate (default=1)
label (str): optional gate label
ctrl_state (int or str or None): The control state in decimal or as a
bit string (e.g. '1011'). If None, use 2**num_ctrl_qubits-1.
Returns:
UnitaryGate: controlled version of gate.
Raises:
QiskitError: Invalid ctrl_state.
ExtensionError: Non-unitary controlled unitary.
"""
cmat = _compute_control_matrix(self.to_matrix(),
num_ctrl_qubits,
ctrl_state=None)
iso = isometry.Isometry(cmat, 0, 0)
cunitary = ControlledGate('c-unitary',
num_qubits=self.num_qubits + num_ctrl_qubits,
params=[cmat],
label=label,
num_ctrl_qubits=num_ctrl_qubits,
definition=iso.definition,
ctrl_state=ctrl_state,
base_gate=self.copy())
from qiskit.quantum_info import Operator
# hack to correct global phase; should fix to prevent need for correction here
pmat = (Operator(iso.inverse()).data @ cmat)
diag = numpy.diag(pmat)
if not numpy.allclose(diag, diag[0]):
raise ExtensionError('controlled unitary generation failed')
phase = numpy.angle(diag[0])
if phase:
# need to apply to _definition since open controls creates temporary definition
cunitary._definition.global_phase = phase
return cunitary
def test_2q_hamiltonian(self):
"""test 2 qubit hamiltonian"""
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
matrix = Operator.from_label("XY")
qc.x(qr[0])
theta = Parameter("theta")
uni2q = HamiltonianGate(matrix, theta)
qc.append(uni2q, [qr[0], qr[1]])
qc2 = qc.bind_parameters({theta: -np.pi / 2})
dag = circuit_to_dag(qc2)
nodes = dag.two_qubit_ops()
self.assertEqual(len(nodes), 1)
dnode = nodes[0]
self.assertIsInstance(dnode.op, HamiltonianGate)
self.assertEqual(dnode.qargs, [qr[0], qr[1]])
# Equality based on Pauli exponential identity
np.testing.assert_array_almost_equal(dnode.op.to_matrix(),
1j * matrix.data)
qc3 = dag_to_circuit(dag)
self.assertEqual(qc2, qc3)
def test_diamond_norm(self, num_qubits):
"""Test the diamond_norm for {num_qubits}-qubit pauli channel."""
try:
import cvxpy
except ImportError:
# Skip test if CVXPY not installed
self.skipTest("CVXPY not installed.")
# Pauli channels have an analytic expression for the
# diamond norm so we can easily test it
op = Choi(np.zeros((4 ** num_qubits, 4 ** num_qubits)))
labels = [num_qubits * i for i in ['I', 'X', 'Y', 'Z']]
coeffs = [-1.0, 0.5, 2.5, -0.1]
for coeff, label in zip(coeffs, labels):
op = op + coeff * Choi(Operator.from_label(label))
target = np.sum(np.abs(coeffs))
try:
value = diamond_norm(op)
self.assertAlmostEqual(value, target, places=4)
except cvxpy.SolverError:
self.skipTest("CVXPY solver failed.")
def run(self, dag):
"""Run the Optimize1qGatesDecomposition pass on `dag`.
Args:
dag (DAGCircuit): the DAG to be optimized.
Returns:
DAGCircuit: the optimized DAG.
"""
if not self.basis:
LOG.info("Skipping pass because no basis is set")
return dag
decomposer = OneQubitEulerDecomposer(self.basis)
runs = dag.collect_runs(self.euler_basis_names[self.basis])
runs = _split_runs_on_parameters(runs)
for run in runs:
if len(run) <= 1:
params = run[0].op.params
# Remove single identity gates
if run[0].op.name in self.euler_basis_names[
self.basis] and len(params) > 0 and np.array_equal(
run[0].op.to_matrix(), np.eye(2)):
dag.remove_op_node(run[0])
# Don't try to optimize a single 1q gate
continue
q = QuantumRegister(1, "q")
qc = QuantumCircuit(1)
for gate in run:
qc.append(gate.op, [q[0]], [])
operator = Operator(qc)
new_circ = decomposer(operator)
new_dag = circuit_to_dag(new_circ)
dag.substitute_node_with_dag(run[0], new_dag)
# Delete the other nodes in the run
for current_node in run[1:]:
dag.remove_op_node(current_node)
return dag
def test_open_controlled_to_matrix(self, gate_class, ctrl_state):
"""Test open controlled to_matrix."""
num_free_params = len(_get_free_params(gate_class.__init__,
ignore=['self']))
free_params = [0.1 * i for i in range(1, num_free_params + 1)]
if gate_class in [MCU1Gate, MCPhaseGate]:
free_params[1] = 3
elif gate_class in [MCXGate]:
free_params[0] = 3
cgate = gate_class(*free_params)
cgate.ctrl_state = ctrl_state
base_mat = Operator(cgate.base_gate).data
if gate_class == CUGate: # account for global phase
base_mat = np.array(base_mat) * np.exp(1j * cgate.params[3])
target = _compute_control_matrix(base_mat, cgate.num_ctrl_qubits,
ctrl_state=ctrl_state)
try:
actual = cgate.to_matrix()
except CircuitError as cerr:
self.skipTest(cerr)
self.assertTrue(np.allclose(actual, target))
def levelOperator(
self,
Level_Num): #Gives the unitary representation of level =Level_Num
QC = self.level(Level_Num)
leveloperator = Operator(QC)
return leveloperator
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from matplotlib import pyplot as plt
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import Operator
import numpy as np
from numpy import sqrt
sim_qasm = Aer.get_backend('qasm_simulator')
U1_op = Operator([[0.5, 0.5, 0.5, 0.5], [0, 0, 1 / sqrt(2), -1 / sqrt(2)],
[1 / sqrt(2), -1 / sqrt(2), 0, 0], [0.5, 0.5, -0.5, -0.5]])
U1_q = QuantumRegister(2)
U1_c = QuantumCircuit(U1_q, name='U1')
U1_c.unitary(U1_op, [0, 1], label='label')
U1 = U1_c.to_gate()
def construct_encode(U):
return U.control(1)
def construct_decode(U):
# circ = QuantumCircuit(3, name='_decode')
circ = QuantumCircuit(3, name=U.name + '_decode')
U_dag = U.inverse()
circ.x(0)
circ.append(U_dag.control(1), [0, 1, 2])
circ.x(0)
return circ.to_gate()
return M_0_E
a, b = np.pi / 2, np.pi / 2
M_0_E = M_0_Eve(a, b)
M_1_E = np.matrix(([-complex(0, 1) / sqrt(2),
1 / sqrt(2)], [complex(0, 1) / sqrt(2), 1 / sqrt(2)]))
ZERO_E = np.zeros([2, 2])
# U_E is an identity matrix (default)
U_E = np.matrix(
np.vstack((np.hstack((M_0_E, ZERO_E)), np.hstack((ZERO_E, M_1_E)))))
U_E_dagger = np.matrix(U_E).H.T
print("U_E: \n", U_E)
print("U_E_dagger: \n", U_E_dagger)
# Operator to gate
U1_op = Operator(U_E)
print("U_E to gate: ", U1_op)
#########################################################################################
# rho #
#########################################################################################
# Alice
rho_i = np.matrix(alice_bits * np.reshape(alice_bits, (1, 4)))
print("rho: \n", rho_i)
# Alice + Bob
rho_i_prime = 0.5 * (rho_i + U_epi * rho_i * U_epi_dagger)
print("rho_i_prime: \n", rho_i_prime)
# Eve mapping "rho_i_prime" --> "rho_E_prime" --> send to Bob to decode --> "rho_E_double_prime" --> measure --> "phi_j"
rho_E_double_prime = 0.5 * (U_E * rho_i * U_E_dagger + U_epi_dagger * U_E *
U_epi * rho_i * U_epi_dagger * U_E_dagger * U_epi)
print("rho_E_double_prime: \n", rho_E_double_prime)
def run(self, dag):
"""Run the ConsolidateBlocks pass on `dag`.
Iterate over each block and replace it with an equivalent Unitary
on the same wires.
"""
if self.decomposer is None:
return dag
# compute ordered indices for the global circuit wires
global_index_map = {wire: idx for idx, wire in enumerate(dag.qubits)}
blocks = self.property_set["block_list"]
basis_gate_name = self.decomposer.gate.name
all_block_gates = set()
for block in blocks:
if len(block) == 1 and (self.basis_gates and block[0].name not in self.basis_gates):
all_block_gates.add(block[0])
dag.substitute_node(block[0], UnitaryGate(block[0].op.to_matrix()))
else:
basis_count = 0
outside_basis = False
block_qargs = set()
block_cargs = set()
for nd in block:
block_qargs |= set(nd.qargs)
if isinstance(nd, DAGOpNode) and nd.op.condition:
block_cargs |= set(nd.op.condition[0])
all_block_gates.add(nd)
q = QuantumRegister(len(block_qargs))
qc = QuantumCircuit(q)
if block_cargs:
c = ClassicalRegister(len(block_cargs))
qc.add_register(c)
block_index_map = self._block_qargs_to_indices(block_qargs, global_index_map)
for nd in block:
if nd.op.name == basis_gate_name:
basis_count += 1
if self.basis_gates and nd.op.name not in self.basis_gates:
outside_basis = True
qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
unitary = UnitaryGate(Operator(qc))
max_2q_depth = 20 # If depth > 20, there will be 1q gates to consolidate.
if ( # pylint: disable=too-many-boolean-expressions
self.force_consolidate
or unitary.num_qubits > 2
or self.decomposer.num_basis_gates(unitary) < basis_count
or len(block) > max_2q_depth
or (self.basis_gates is not None and outside_basis)
):
dag.replace_block_with_op(block, unitary, block_index_map, cycle_check=False)
# If 1q runs are collected before consolidate those too
runs = self.property_set["run_list"] or []
for run in runs:
if run[0] in all_block_gates:
continue
if len(run) == 1 and self.basis_gates and run[0].name not in self.basis_gates:
dag.substitute_node(run[0], UnitaryGate(run[0].op.to_matrix()))
else:
qubit = run[0].qargs[0]
operator = run[0].op.to_matrix()
already_in_block = False
for gate in run[1:]:
if gate in all_block_gates:
already_in_block = True
operator = gate.op.to_matrix().dot(operator)
if already_in_block:
continue
unitary = UnitaryGate(operator)
dag.replace_block_with_op(run, unitary, {qubit: 0}, cycle_check=False)
return dag
def _expand_dim(self, num_qubits: int) -> 'MatrixOp':
identity = np.identity(2**num_qubits, dtype=complex)
return MatrixOp(self.primitive.tensor(Operator(identity)),
coeff=self.coeff) # type: ignore
#!/usr/bin/env python # coding: utf-8 # In[140]: from qiskit import * from qiskit.quantum_info import Operator, average_gate_fidelity from math import pi import numpy as np import cmath a1 = complex(0, 1) op_1 = Operator([[a1, 0], [0, a1]]) from qiskit.visualization import plot_bloch_multivector, plot_histogram qc = QuantumCircuit(2, 2) # Applied H-gate = iRx(pi)Ry(pi/2): #Applied X-gate = iRx(pi) # here unitary gate is global phase i qc.ry(pi / 2, 0) qc.rx(pi, 0) qc.unitary(op_1, [0]) # Applied C-NOT gate to both qubits qc.cx(0, 1) # Applied X-gate to first qubit qc.rx(pi, 0) qc.unitary(op_1, [0]) qc.draw()
def test_open_controlled_unitary_z(self, num_ctrl_qubits, ctrl_state):
"""Test that UnitaryGate with control returns params."""
umat = np.array([[1, 0], [0, -1]])
ugate = UnitaryGate(umat).control(num_ctrl_qubits, ctrl_state=ctrl_state)
ref_mat = _compute_control_matrix(umat, num_ctrl_qubits, ctrl_state=ctrl_state)
self.assertTrue(matrix_equal(Operator(ugate).data, ref_mat))
def test_cry_definition(self):
"""Test cry gate matrix and definition."""
circ = QuantumCircuit(2)
circ.cry(1, 0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_rotation_gates(self):
"""Test controlled rotation gates"""
import qiskit.extensions.standard.u1 as u1
import qiskit.extensions.standard.rx as rx
import qiskit.extensions.standard.ry as ry
import qiskit.extensions.standard.rz as rz
num_ctrl = 2
num_target = 1
qreg = QuantumRegister(num_ctrl + num_target)
theta = pi / 2
gu1 = u1.U1Gate(theta)
grx = rx.RXGate(theta)
gry = ry.RYGate(theta)
grz = rz.RZGate(theta)
ugu1 = ac._unroll_gate(gu1, ['u1', 'u3', 'cx'])
ugrx = ac._unroll_gate(grx, ['u1', 'u3', 'cx'])
ugry = ac._unroll_gate(gry, ['u1', 'u3', 'cx'])
ugrz = ac._unroll_gate(grz, ['u1', 'u3', 'cx'])
ugrz.params = grz.params
cgu1 = ugu1.control(num_ctrl)
cgrx = ugrx.control(num_ctrl)
cgry = ugry.control(num_ctrl)
cgrz = ugrz.control(num_ctrl)
for gate, cgate in zip([gu1, grx, gry, grz], [cgu1, cgrx, cgry, cgrz]):
with self.subTest(i=gate.name):
if gate.name == 'rz':
iden = Operator.from_label('I')
zgen = Operator.from_label('Z')
op_mat = (np.cos(0.5 * theta) * iden -
1j * np.sin(0.5 * theta) * zgen).data
else:
op_mat = Operator(gate).data
ref_mat = Operator(cgate).data
cop_mat = _compute_control_matrix(op_mat, num_ctrl)
self.assertTrue(
matrix_equal(cop_mat, ref_mat, ignore_phase=True))
cqc = QuantumCircuit(num_ctrl + num_target)
cqc.append(cgate, cqc.qregs[0])
dag = circuit_to_dag(cqc)
unroller = Unroller(['u3', 'cx'])
uqc = dag_to_circuit(unroller.run(dag))
self.log.info('%s gate count: %d', cgate.name, uqc.size())
self.log.info('\n%s', str(uqc))
# these limits could be changed
if gate.name == 'ry':
self.assertTrue(uqc.size() <= 32)
elif gate.name == 'rz':
self.assertTrue(uqc.size() <= 40)
else:
self.assertTrue(uqc.size() <= 20)
qc = QuantumCircuit(qreg, name='composite')
qc.append(grx.control(num_ctrl), qreg)
qc.append(gry.control(num_ctrl), qreg)
qc.append(gry, qreg[0:gry.num_qubits])
qc.append(grz.control(num_ctrl), qreg)
dag = circuit_to_dag(qc)
unroller = Unroller(['u3', 'cx'])
uqc = dag_to_circuit(unroller.run(dag))
print(uqc.size())
self.log.info('%s gate count: %d', uqc.name, uqc.size())
self.assertTrue(uqc.size() <= 93) # this limit could be changed
def test_cu3_definition(self):
"""Test cu3 gate matrix and definition."""
circ = QuantumCircuit(2)
circ.append(CU3Gate(1, 1, 1), [0, 1])
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_repeat_global_phase(self, num):
"""Test the global phase is properly handled upon repeat."""
phase = 0.123
qc = QuantumCircuit(1, global_phase=phase)
expected = np.exp(1j * phase * num) * np.identity(2)
np.testing.assert_array_almost_equal(Operator(qc.repeat(num)).data, expected)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
#import numpy as np
n = 3 #number of qubits
qs = QuantumCircuit(n)
qs.h(1)
qs.x(0)
qs.h(2)
initial_state = np.zeros(2**n)
initial_state[0] = 1
U = Operator(qs)
G_wrapper = Graph_Wrapper(U,initial_state)
graph_data = G_wrapper.data
del graph_data["directed"]
del graph_data["multigraph"]
del graph_data["graph"]
#print(graph_data)
html1 = """<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset="utf-8">
<title>Qflow - A Quantum Game</title>
<style type="text/css">
canvas {
def test_ch_definition(self): # TODO: expand this to all gates
"""Test ch gate matrix and definition."""
circ = QuantumCircuit(2)
circ.ch(0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
# Create a Quantum Circuit acting on a quantum register of three qubits circ = QuantumCircuit(3) # Add a H gate on qubit 0, putting this qubit in superposition. circ.h(0) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. circ.cx(0, 1) # Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting # the qubits in a GHZ state. circ.cx(0, 2) from qiskit.quantum_info import Operator U = Operator(circ) # Show the results U.data meas = QuantumCircuit(3, 3) meas.barrier(range(3)) # map the quantum measurement to the classical bits meas.measure(range(3), range(3)) # The Qiskit circuit object supports composition. # Here the meas has to be first and front=True (putting it before) # as compose must put a smaller circuit into a larger one. qc = meas.compose(circ, range(3), front=True) #drawing the circuit
def test_nontp_process_fidelity(self):
"""Test process_fidelity for non-TP channel"""
chan = 0.99 * Choi(Operator.from_label('X'))
fid = process_fidelity(chan)
self.assertLogs('qiskit.quantum_info.operators.measures', level='WARNING')
self.assertAlmostEqual(fid, 0, places=15)
def test_parametric_template(self):
"""
Check matching where template has parameters.
┌───────────┐ ┌────────┐
q_0: ┤ P(-1.0*β) ├──■────────────■──┤0 ├
├───────────┤┌─┴─┐┌──────┐┌─┴─┐│ CZ(β) │
q_1: ┤ P(-1.0*β) ├┤ X ├┤ P(β) ├┤ X ├┤1 ├
└───────────┘└───┘└──────┘└───┘└────────┘
First test try match on
┌───────┐
q_0: ┤ P(-2) ├──■────────────■─────────────────────────────
├───────┤┌─┴─┐┌──────┐┌─┴─┐┌───────┐
q_1: ┤ P(-2) ├┤ X ├┤ P(2) ├┤ X ├┤ P(-3) ├──■────────────■──
├───────┤└───┘└──────┘└───┘└───────┘┌─┴─┐┌──────┐┌─┴─┐
q_2: ┤ P(-3) ├───────────────────────────┤ X ├┤ P(3) ├┤ X ├
└───────┘ └───┘└──────┘└───┘
Second test try match on
┌───────┐
q_0: ┤ P(-2) ├──■────────────■────────────────────────────
├───────┤┌─┴─┐┌──────┐┌─┴─┐┌──────┐
q_1: ┤ P(-2) ├┤ X ├┤ P(2) ├┤ X ├┤ P(3) ├──■────────────■──
└┬──────┤└───┘└──────┘└───┘└──────┘┌─┴─┐┌──────┐┌─┴─┐
q_2: ─┤ P(3) ├──────────────────────────┤ X ├┤ P(3) ├┤ X ├
└──────┘ └───┘└──────┘└───┘
"""
class CZp(Gate):
"""CZ gates used for the test."""
def __init__(self, num_qubits, params):
super().__init__('cz', num_qubits, params)
def inverse(self):
inverse = UnitaryGate(
np.diag([1.0, 1.0, 1.0,
np.exp(-2.0j * self.params[0])]))
inverse.name = 'icz'
return inverse
def template_czp2():
beta = Parameter('β')
qc = QuantumCircuit(2)
qc.p(-beta, 0)
qc.p(-beta, 1)
qc.cx(0, 1)
qc.p(beta, 1)
qc.cx(0, 1)
qc.append(CZp(2, [beta]), [0, 1])
return qc
def count_cx(qc):
"""Counts the number of CX gates for testing."""
return qc.count_ops().get('cx', 0)
circuit_in = QuantumCircuit(3)
circuit_in.p(-2, 0)
circuit_in.p(-2, 1)
circuit_in.cx(0, 1)
circuit_in.p(2, 1)
circuit_in.cx(0, 1)
circuit_in.p(-3, 1)
circuit_in.p(-3, 2)
circuit_in.cx(1, 2)
circuit_in.p(3, 2)
circuit_in.cx(1, 2)
pass_ = TemplateOptimization(template_list=[template_czp2()])
circuit_out = PassManager(pass_).run(circuit_in)
np.testing.assert_almost_equal(
Operator(circuit_out).data[3, 3], np.exp(-4.j))
np.testing.assert_almost_equal(
Operator(circuit_out).data[7, 7], np.exp(-10.j))
self.assertEqual(count_cx(circuit_out),
0) # Two matches => no CX gates.
np.testing.assert_almost_equal(
Operator(circuit_in).data,
Operator(circuit_out).data)
circuit_in = QuantumCircuit(3)
circuit_in.p(-2, 0)
circuit_in.p(-2, 1)
circuit_in.cx(0, 1)
circuit_in.p(2, 1)
circuit_in.cx(0, 1)
circuit_in.p(3, 1)
circuit_in.p(3, 2)
circuit_in.cx(1, 2)
circuit_in.p(3, 2)
circuit_in.cx(1, 2)
pass_ = TemplateOptimization(template_list=[template_czp2()])
circuit_out = PassManager(pass_).run(circuit_in)
self.assertEqual(count_cx(circuit_out),
2) # One match => two CX gates.
np.testing.assert_almost_equal(
Operator(circuit_in).data,
Operator(circuit_out).data)
def test_ccx_definition(self):
"""Test ccx gate matrix and definition."""
circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_evals(self):
"""evals test"""
# TODO: Think about eval names
self.assertEqual(Z.eval("0").eval("0"), 1)
self.assertEqual(Z.eval("1").eval("0"), 0)
self.assertEqual(Z.eval("0").eval("1"), 0)
self.assertEqual(Z.eval("1").eval("1"), -1)
self.assertEqual(X.eval("0").eval("0"), 0)
self.assertEqual(X.eval("1").eval("0"), 1)
self.assertEqual(X.eval("0").eval("1"), 1)
self.assertEqual(X.eval("1").eval("1"), 0)
self.assertEqual(Y.eval("0").eval("0"), 0)
self.assertEqual(Y.eval("1").eval("0"), -1j)
self.assertEqual(Y.eval("0").eval("1"), 1j)
self.assertEqual(Y.eval("1").eval("1"), 0)
with self.assertRaises(ValueError):
Y.eval("11")
with self.assertRaises(ValueError):
(X ^ Y).eval("1111")
with self.assertRaises(ValueError):
Y.eval((X ^ X).to_matrix_op())
# Check that Pauli logic eval returns same as matrix logic
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval("0").eval("0"), 1)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval("1").eval("0"), 0)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval("0").eval("1"), 0)
self.assertEqual(PrimitiveOp(Z.to_matrix()).eval("1").eval("1"), -1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval("0").eval("0"), 0)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval("1").eval("0"), 1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval("0").eval("1"), 1)
self.assertEqual(PrimitiveOp(X.to_matrix()).eval("1").eval("1"), 0)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval("0").eval("0"), 0)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval("1").eval("0"), -1j)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval("0").eval("1"), 1j)
self.assertEqual(PrimitiveOp(Y.to_matrix()).eval("1").eval("1"), 0)
pauli_op = Z ^ I ^ X ^ Y
mat_op = PrimitiveOp(pauli_op.to_matrix())
full_basis = list(
map("".join, itertools.product("01", repeat=pauli_op.num_qubits)))
for bstr1, bstr2 in itertools.product(full_basis, full_basis):
# print('{} {} {} {}'.format(bstr1, bstr2, pauli_op.eval(bstr1, bstr2),
# mat_op.eval(bstr1, bstr2)))
np.testing.assert_array_almost_equal(
pauli_op.eval(bstr1).eval(bstr2),
mat_op.eval(bstr1).eval(bstr2))
gnarly_op = SummedOp(
[
(H ^ I ^ Y).compose(X ^ X ^ Z).tensor(Z),
PrimitiveOp(Operator.from_label("+r0I")),
3 * (X ^ CX ^ T),
],
coeff=3 + 0.2j,
)
gnarly_mat_op = PrimitiveOp(gnarly_op.to_matrix())
full_basis = list(
map("".join, itertools.product("01", repeat=gnarly_op.num_qubits)))
for bstr1, bstr2 in itertools.product(full_basis, full_basis):
np.testing.assert_array_almost_equal(
gnarly_op.eval(bstr1).eval(bstr2),
gnarly_mat_op.eval(bstr1).eval(bstr2))
def test_adjoint(self):
""" adjoint test """
gnarly_op = 3 * (H ^ I ^ Y).compose(X ^ X ^ Z).tensor(T ^ Z) + \
PrimitiveOp(Operator.from_label('+r0IX').data)
np.testing.assert_array_almost_equal(np.conj(np.transpose(gnarly_op.to_matrix())),
gnarly_op.adjoint().to_matrix())
def get_fidelity_with_qiskit(dag_cir, noisy_position):
cir = dag_2_circuit(dag_cir)
U = Operator(cir)
channel = get_error_channel(dag_cir, noisy_position, 0.001)
fide = process_fidelity(channel, U)
return fide
def test_unroll_all_instructions(self):
"""Test unrolling a circuit containing all standard instructions.
"""
qr = QuantumRegister(3, 'qr')
cr = ClassicalRegister(3, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.crx(0.5, qr[1], qr[2])
circuit.cry(0.5, qr[1], qr[2])
circuit.ccx(qr[0], qr[1], qr[2])
circuit.ch(qr[0], qr[2])
circuit.crz(0.5, qr[1], qr[2])
circuit.cswap(qr[1], qr[0], qr[2])
circuit.append(CU1Gate(0.1), [qr[0], qr[2]])
circuit.append(CU3Gate(0.2, 0.1, 0.0), [qr[1], qr[2]])
circuit.cx(qr[1], qr[0])
circuit.cy(qr[1], qr[2])
circuit.cz(qr[2], qr[0])
circuit.h(qr[1])
circuit.i(qr[0])
circuit.rx(0.1, qr[0])
circuit.ry(0.2, qr[1])
circuit.rz(0.3, qr[2])
circuit.rzz(0.6, qr[1], qr[0])
circuit.s(qr[0])
circuit.sdg(qr[1])
circuit.swap(qr[1], qr[2])
circuit.t(qr[2])
circuit.tdg(qr[0])
circuit.append(U1Gate(0.1), [qr[1]])
circuit.append(U2Gate(0.2, -0.1), [qr[0]])
circuit.append(U3Gate(0.3, 0.0, -0.1), [qr[2]])
circuit.x(qr[2])
circuit.y(qr[1])
circuit.z(qr[0])
# circuit.snapshot('0')
# circuit.measure(qr, cr)
dag = circuit_to_dag(circuit)
pass_ = UnrollCustomDefinitions(std_eqlib, ['u3', 'cx', 'id'])
dag = pass_.run(dag)
pass_ = BasisTranslator(std_eqlib, ['u3', 'cx', 'id'])
unrolled_dag = pass_.run(dag)
ref_circuit = QuantumCircuit(qr, cr)
ref_circuit.append(U3Gate(0, 0, pi / 2), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(-0.25, 0, 0), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0.25, -pi / 2, 0), [qr[2]])
ref_circuit.append(U3Gate(0.25, 0, 0), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(-0.25, 0, 0), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[1]])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.cx(qr[0], qr[1])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[0]])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[1]])
ref_circuit.cx(qr[0], qr[1])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.append(U3Gate(0, 0, pi / 2), [qr[2]])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[2]])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.append(U3Gate(0, 0, -pi / 2), [qr[2]])
ref_circuit.append(U3Gate(0, 0, 0.25), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0, 0, -0.25), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.cx(qr[2], qr[0])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[0]])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.cx(qr[1], qr[0])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[0]])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[1]])
ref_circuit.cx(qr[1], qr[0])
ref_circuit.append(U3Gate(0, 0, 0.05), [qr[1]])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[2]])
ref_circuit.cx(qr[2], qr[0])
ref_circuit.append(U3Gate(0, 0, 0.05), [qr[0]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, -0.05), [qr[2]])
ref_circuit.cx(qr[0], qr[2])
ref_circuit.append(U3Gate(0, 0, 0.05), [qr[2]])
ref_circuit.append(U3Gate(0, 0, -0.05), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(-0.1, 0, -0.05), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.cx(qr[1], qr[0])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[0]])
ref_circuit.append(U3Gate(0.1, 0.1, 0), [qr[2]])
ref_circuit.append(U3Gate(0, 0, -pi / 2), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[1]])
ref_circuit.append(U3Gate(0.2, 0, 0), [qr[1]])
ref_circuit.append(U3Gate(0, 0, pi / 2), [qr[2]])
ref_circuit.cx(qr[2], qr[0])
ref_circuit.append(U3Gate(pi / 2, 0, pi), [qr[0]])
ref_circuit.i(qr[0])
ref_circuit.append(U3Gate(0.1, -pi / 2, pi / 2), [qr[0]])
ref_circuit.cx(qr[1], qr[0])
ref_circuit.append(U3Gate(0, 0, 0.6), [qr[0]])
ref_circuit.cx(qr[1], qr[0])
ref_circuit.append(U3Gate(0, 0, pi / 2), [qr[0]])
ref_circuit.append(U3Gate(0, 0, -pi / 4), [qr[0]])
ref_circuit.append(U3Gate(pi / 2, 0.2, -0.1), [qr[0]])
ref_circuit.append(U3Gate(0, 0, pi), [qr[0]])
ref_circuit.append(U3Gate(0, 0, -pi / 2), [qr[1]])
ref_circuit.append(U3Gate(0, 0, 0.3), [qr[2]])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.cx(qr[2], qr[1])
ref_circuit.cx(qr[1], qr[2])
ref_circuit.append(U3Gate(0, 0, 0.1), [qr[1]])
ref_circuit.append(U3Gate(pi, pi / 2, pi / 2), [qr[1]])
ref_circuit.append(U3Gate(0, 0, pi / 4), [qr[2]])
ref_circuit.append(U3Gate(0.3, 0.0, -0.1), [qr[2]])
ref_circuit.append(U3Gate(pi, 0, pi), [qr[2]])
# ref_circuit.snapshot('0')
# ref_circuit.measure(qr, cr)
# ref_dag = circuit_to_dag(ref_circuit)
self.assertTrue(
Operator(dag_to_circuit(unrolled_dag)).equiv(ref_circuit))
