def test_represent_operations_in_circuit_with_measurements(
circuit_type: str,
rep_function,
):
"""Tests measurements in circuit are ignored (not represented)."""
q0, q1 = LineQubit.range(2)
circ_mitiq = Circuit(
X(q1),
MeasurementGate(num_qubits=1)(q0),
X(q1),
MeasurementGate(num_qubits=1)(q0),
)
circ = convert_from_mitiq(circ_mitiq, circuit_type)
reps = rep_function(ideal_circuit=circ, noise_level=0.1)
for op in convert_to_mitiq(circ)[0].all_operations():
found = False
for rep in reps:
if _equal(rep.ideal, Circuit(op), require_qubit_equality=True):
found = True
if isinstance(op.gate, MeasurementGate):
assert not found
else:
assert found
# Number of unique gates excluding measurement gates
assert len(reps) == 1
def test_execute_with_pec_mitigates_noise(circuit, executor, circuit_type):
"""Tests that execute_with_pec mitigates the error of a noisy
expectation value.
"""
circuit = convert_from_mitiq(circuit, circuit_type)
true_noiseless_value = 1.0
unmitigated = serial_executor(circuit)
if circuit_type == "qiskit":
# Note this is an important subtlety necessary because of conversions.
reps = get_pauli_representations(
base_noise=BASE_NOISE,
qubits=[cirq.NamedQubit(name) for name in ("q_0", "q_1")],
)
# TODO: PEC with Qiskit is slow.
# See https://github.com/unitaryfund/mitiq/issues/507.
circuit, _ = convert_to_mitiq(circuit)
else:
reps = pauli_representations
mitigated = execute_with_pec(
circuit,
executor,
representations=reps,
force_run_all=False,
random_state=101,
)
error_unmitigated = abs(unmitigated - true_noiseless_value)
error_mitigated = abs(mitigated - true_noiseless_value)
assert error_mitigated < error_unmitigated
assert np.isclose(mitigated, true_noiseless_value, atol=0.1)
def test_amplitude_damping_representation_with_choi(
gate: Gate,
noise: float,
circuit_type: str,
):
"""Tests the representation by comparing exact Choi matrices."""
q = LineQubit(0)
ideal_circuit = convert_from_mitiq(Circuit(gate.on(q)), circuit_type)
ideal_choi = _circuit_to_choi(Circuit(gate.on(q)))
op_rep = _represent_operation_with_amplitude_damping_noise(
ideal_circuit,
noise,
)
choi_components = []
for noisy_op, coeff in op_rep.basis_expansion.items():
implementable_circ = noisy_op.ideal_circuit()
depolarizing_op = AmplitudeDampingChannel(noise).on(q)
# Apply noise after each sequence.
# NOTE: noise is not applied after each operation.
implementable_circ.append(depolarizing_op)
sequence_choi = _operation_to_choi(implementable_circ)
choi_components.append(coeff * sequence_choi)
combination_choi = np.sum(choi_components, axis=0)
assert np.allclose(ideal_choi, combination_choi, atol=10**-8)
def test_find_optimal_representation_depolarizing_two_qubit_gates(circ_type):
"""Test optimal representation agrees with a known analytic result."""
for ideal_gate, noise_level in product([CNOT, CZ], [0.1, 0.5]):
q = LineQubit.range(2)
ideal_op = Circuit(ideal_gate(*q))
implementable_circuits = [Circuit(ideal_op)]
# Append two-qubit-gate with Paulis on one qubit
for gate in [X, Y, Z]:
implementable_circuits.append(Circuit([ideal_op, gate(q[0])]))
implementable_circuits.append(Circuit([ideal_op, gate(q[1])]))
# Append two-qubit gate with Paulis on both qubits
for gate_a, gate_b in product([X, Y, Z], repeat=2):
implementable_circuits.append(
Circuit([ideal_op, gate_a(q[0]),
gate_b(q[1])]))
noisy_circuits = [
circ + Circuit(DepolarizingChannel(noise_level).on_each(*q))
for circ in implementable_circuits
]
super_operators = [
choi_to_super(_circuit_to_choi(circ)) for circ in noisy_circuits
]
# Define circuits with native types
implementable_native = [
convert_from_mitiq(c, circ_type) for c in implementable_circuits
]
ideal_op_native = convert_from_mitiq(ideal_op, circ_type)
noisy_operations = [
NoisyOperation(ideal, real)
for ideal, real in zip(implementable_native, super_operators)
]
# Find optimal representation
noisy_basis = NoisyBasis(*noisy_operations)
rep = find_optimal_representation(ideal_op_native,
noisy_basis,
tol=1.0e-8)
# Expected analytical result
expected_rep = represent_operation_with_local_depolarizing_noise(
ideal_op_native,
noise_level,
)
assert np.allclose(np.sort(rep.coeffs), np.sort(expected_rep.coeffs))
assert rep == expected_rep
def sample_circuit(
ideal_circuit: QPROGRAM,
representations: List[OperationRepresentation],
random_state: Optional[Union[int, np.random.RandomState]] = None,
) -> Tuple[QPROGRAM, int, float]:
"""Samples an implementable circuit from the PEC representation of the
input ideal circuit & returns this circuit as well as its sign and norm.
This function iterates through each operation in the circuit and samples
an implementable sequence. The returned sign (norm) is the product of signs
(norms) sampled for each operation.
Args:
ideal_circuit: The ideal circuit from which an implementable circuit
is sampled.
representations: List of representations of every operation in the
input circuit. If a representation cannot be found for an operation
in the circuit, a ValueError is raised.
random_state: Seed for sampling.
Returns:
imp_circuit: The sampled implementable circuit.
sign: The sign associated to sampled_circuit.
norm: The one norm of the PEC coefficients of the circuit.
Raises:
ValueError:
If a representation is not found for an operation in the circuit.
"""
if isinstance(random_state, int):
random_state = np.random.RandomState(random_state)
# TODO: Likely to cause issues - conversions may introduce gates which are
# not included in `decompositions`.
ideal, rtype = convert_to_mitiq(ideal_circuit)
# copy and remove all moments
sampled_circuit = deepcopy(ideal)[0:0]
# Iterate over all operations
sign = 1
norm = 1.0
for op in ideal.all_operations():
# Ignore all measurements.
if cirq.is_measurement(op):
continue
imp_seq, loc_sign, loc_norm = sample_sequence(cirq.Circuit(op),
representations,
random_state)
cirq_seq, _ = convert_to_mitiq(imp_seq)
sign *= loc_sign
norm *= loc_norm
sampled_circuit.append(cirq_seq.all_operations())
return convert_from_mitiq(sampled_circuit, rtype), sign, norm
def test_find_optimal_representation_single_qubit_amp_damping(circ_type):
"""Test optimal representation of agrees with a known analytic result."""
for ideal_gate, noise_level in product([X, Y, H], [0.1, 0.3]):
q = LineQubit(0)
ideal_op = Circuit(ideal_gate(q))
implementable_circuits = [Circuit(ideal_op)]
# Add ideal gate followed by Paulis and reset
for gate in [Z, reset]:
implementable_circuits.append(Circuit([ideal_op, gate(q)]))
noisy_circuits = [
circ + Circuit(AmplitudeDampingChannel(noise_level).on_each(q))
for circ in implementable_circuits
]
super_operators = [
choi_to_super(_circuit_to_choi(circ)) for circ in noisy_circuits
]
# Define circuits with native types
implementable_native = [
convert_from_mitiq(c, circ_type) for c in implementable_circuits
]
ideal_op_native = convert_from_mitiq(ideal_op, circ_type)
noisy_operations = [
NoisyOperation(ideal, real)
for ideal, real in zip(implementable_native, super_operators)
]
# Find optimal representation
noisy_basis = NoisyBasis(*noisy_operations)
rep = find_optimal_representation(ideal_op_native,
noisy_basis,
tol=1.0e-8)
# Expected analytical result
expected_rep = _represent_operation_with_amplitude_damping_noise(
ideal_op_native,
noise_level,
)
assert np.allclose(np.sort(rep.coeffs), np.sort(expected_rep.coeffs))
assert rep == expected_rep
def ideal_circuit(self, return_type: Optional[str] = None) -> cirq.Circuit:
"""Returns the ideal circuit of the NoisyOperation.
Args:
return_type: Type of the circuit to return.
If not specified, the returned type is the same type as the
circuit used to initialize the NoisyOperation.
"""
if not return_type:
return self._native_ideal
return convert_from_mitiq(self._ideal, return_type)
def run(
self,
circuits: Sequence[QPROGRAM],
force_run_all: bool = False,
**kwargs,
) -> List[float]:
"""Runs all input circuits using the least number of possible calls to
the executor.
Args:
circuits: Sequence of circuits to execute using the executor.
force_run_all: If True, force every circuit in the input sequence
to be executed (if some are identical). Else, detects identical
circuits and runs a minimal set.
"""
if force_run_all:
to_run = circuits
else:
# Make circuits hashable.
# Note: Assumes all circuits are the same type.
_, conversion_type = convert_to_mitiq(circuits[0])
hashable_circuits = [
convert_to_mitiq(circ)[0].freeze() for circ in circuits
]
# Get the unique circuits and counts
collection = Counter(hashable_circuits)
to_run = [
convert_from_mitiq(circ.unfreeze(), conversion_type)
for circ in collection.keys()
]
if not self._can_batch:
for circuit in to_run:
self._call_executor(circuit, **kwargs)
else:
stop = len(to_run)
step = self._max_batch_size
for i in range(int(np.ceil(stop / step))):
batch = to_run[i * step:(i + 1) * step]
self._call_executor(batch, **kwargs)
# Expand computed results to all results using counts.
if force_run_all:
return self._computed_results
expval_dict = dict(zip(collection.keys(), self._computed_results))
results = [expval_dict[key] for key in hashable_circuits]
return results
def generate_rb_circuits(
n_qubits: int,
num_cliffords: int,
trials: int = 1,
return_type: Optional[str] = None,
) -> List[QPROGRAM]:
"""Returns a list of randomized benchmarking circuits, i.e. circuits that
are equivalent to the identity.
Args:
n_qubits: The number of qubits. Can be either 1 or 2.
num_cliffords: The number of Clifford group elements in the
random circuits. This is proportional to the depth per circuit.
trials: The number of random circuits at each num_cfd.
return_type: String which specifies the type of the
returned circuits. See the keys of ``mitiq.QPROGRAM`` for options.
If ``None``, the returned circuits are type ``cirq.Circuit``.
Returns:
A list of randomized benchmarking circuits.
"""
if n_qubits not in (1, 2):
raise ValueError("Only generates RB circuits on one or two "
f"qubits not {n_qubits}.")
qubits = LineQubit.range(n_qubits)
cliffords = _single_qubit_cliffords()
if n_qubits == 1:
c1 = cliffords.c1_in_xy
cfd_mat_1q = [_gate_seq_to_mats(gates) for gates in c1]
circuits = [
_random_single_q_clifford(*qubits, num_cliffords, c1, cfd_mat_1q)
for _ in range(trials)
]
else:
cfd_matrices = _two_qubit_clifford_matrices(
*qubits,
cliffords, # type: ignore
)
circuits = [
_random_two_q_clifford(
*qubits, # type: ignore
num_cliffords,
cfd_matrices,
cliffords,
) for _ in range(trials)
]
if return_type is None or return_type == "cirq":
return circuits
return [convert_from_mitiq(circuit, return_type) for circuit in circuits]
def test_represent_operations_in_circuit_local(circuit_type: str):
"""Tests all operation representations are created."""
qreg = LineQubit.range(2)
circ_mitiq = Circuit([CNOT(*qreg), H(qreg[0]), Y(qreg[1]), CNOT(*qreg)])
circ = convert_from_mitiq(circ_mitiq, circuit_type)
reps = represent_operations_in_circuit_with_local_depolarizing_noise(
ideal_circuit=circ,
noise_level=0.1,
)
for op in convert_to_mitiq(circ)[0].all_operations():
found = False
for rep in reps:
if _equal(rep.ideal, Circuit(op), require_qubit_equality=True):
found = True
assert found
# The number of reps. should match the number of unique operations
assert len(reps) == 3
def test_from_mitiq(to_type):
converted_circuit = convert_from_mitiq(cirq_circuit, to_type)
circuit, input_type = convert_to_mitiq(converted_circuit)
assert _equal(circuit, cirq_circuit)
assert input_type == to_type
def represent_operation_with_global_depolarizing_noise(
ideal_operation: QPROGRAM,
noise_level: float) -> OperationRepresentation:
r"""As described in [Temme2017]_, this function maps an
``ideal_operation`` :math:`\mathcal{U}` into its quasi-probability
representation, which is a linear combination of noisy implementable
operations :math:`\sum_\alpha \eta_{\alpha} \mathcal{O}_{\alpha}`.
This function assumes a depolarizing noise model and, more precicely,
that the following noisy operations are implementable
:math:`\mathcal{O}_{\alpha} = \mathcal{D} \circ \mathcal P_\alpha
\circ \mathcal{U}`, where :math:`\mathcal{U}` is the unitary associated
to the input ``ideal_operation`` acting on :math:`k` qubits,
:math:`\mathcal{P}_\alpha` is a Pauli operation and
:math:`\mathcal{D}(\rho) = (1 - \epsilon) \rho + \epsilon I/2^k` is a
depolarizing channel (:math:`\epsilon` is a simple function of
``noise_level``).
For a single-qubit ``ideal_operation``, the representation is as
follows:
.. math::
\mathcal{U}_{\beta} = \eta_1 \mathcal{O}_1 + \eta_2 \mathcal{O}_2 +
\eta_3 \mathcal{O}_3 + \eta_4 \mathcal{O}_4
.. math::
\eta_1 =1 + \frac{3}{4} \frac{\epsilon}{1- \epsilon},
\qquad \mathcal{O}_1 = \mathcal{D} \circ \mathcal{I} \circ \mathcal{U}
\eta_2 =- \frac{1}{4}\frac{\epsilon}{1- \epsilon} , \qquad
\mathcal{O}_2 = \mathcal{D} \circ \mathcal{X} \circ \mathcal{U}
\eta_3 =- \frac{1}{4}\frac{\epsilon}{1- \epsilon} , \qquad
\mathcal{O}_3 = \mathcal{D} \circ \mathcal{Y} \circ \mathcal{U}
\eta_4 =- \frac{1}{4}\frac{\epsilon}{1- \epsilon} , \qquad
\mathcal{O}_4 = \mathcal{D} \circ \mathcal{Z} \circ \mathcal{U}
It was proven in [Takagi2020]_ that, under suitable assumptions,
this representation is optimal (minimum 1-norm).
Args:
ideal_operation: The ideal operation (as a QPROGRAM) to represent.
noise_level: The noise level (as a float) of the depolarizing channel.
Returns:
The quasi-probability representation of the ``ideal_operation``.
.. note::
This representation is based on the ideal assumption that one
can append Pauli gates to a noisy operation without introducing
additional noise. For a beckend which violates this assumption,
it remains a good approximation for small values of ``noise_level``.
.. note::
The input ``ideal_operation`` is typically a QPROGRAM with a single
gate but could also correspond to a sequence of more gates.
This is possible as long as the unitary associated to the input
QPROGRAM, followed by a single final depolarizing channel, is
physically implementable.
"""
circ, in_type = convert_to_mitiq(ideal_operation)
post_ops: List[List[Operation]]
qubits = circ.all_qubits()
# The single-qubit case: linear combination of 1Q Paulis
if len(qubits) == 1:
q = tuple(qubits)[0]
epsilon = 4 / 3 * noise_level
alpha_pos = 1 + ((3 / 4) * epsilon / (1 - epsilon))
alpha_neg = -(1 / 4) * epsilon / (1 - epsilon)
alphas = [alpha_pos] + 3 * [alpha_neg]
post_ops = [[]] # for alpha_pos, we do nothing, rather than I
post_ops += [[P(q)] for P in [X, Y, Z]] # 1Q Paulis
# The two-qubit case: linear combination of 2Q Paulis
elif len(qubits) == 2:
q0, q1 = qubits
epsilon = 16 / 15 * noise_level
alpha_pos = 1 + ((15 / 16) * epsilon / (1 - epsilon))
alpha_neg = -(1 / 16) * epsilon / (1 - epsilon)
alphas = [alpha_pos] + 15 * [alpha_neg]
post_ops = [[]] # for alpha_pos, we do nothing, rather than I x I
post_ops += [[P(q0)] for P in [X, Y, Z]] # 1Q Paulis for q0
post_ops += [[P(q1)] for P in [X, Y, Z]] # 1Q Paulis for q1
post_ops += [[Pi(q0), Pj(q1)] for Pi in [X, Y, Z]
for Pj in [X, Y, Z]] # 2Q Paulis
else:
raise ValueError("Can only represent single- and two-qubit gates."
"Consider pre-compiling your circuit.")
# Basis of implementable operations as circuits
imp_op_circuits = [circ + Circuit(op) for op in post_ops]
# Convert back to input type
imp_op_circuits = [convert_from_mitiq(c, in_type) for c in imp_op_circuits]
# Build basis_expantion
expansion = {NoisyOperation(c): a for c, a in zip(imp_op_circuits, alphas)}
return OperationRepresentation(ideal_operation, expansion)
def represent_operation_with_local_depolarizing_noise(
ideal_operation: QPROGRAM,
noise_level: float) -> OperationRepresentation:
r"""As described in [Temme2017]_, this function maps an
``ideal_operation`` :math:`\mathcal{U}` into its quasi-probability
representation, which is a linear combination of noisy implementable
operations :math:`\sum_\alpha \eta_{\alpha} \mathcal{O}_{\alpha}`.
This function assumes a (local) single-qubit depolarizing noise model even
for multi-qubit operations. More precicely, it assumes that the following
noisy operations are implementable :math:`\mathcal{O}_{\alpha} =
\mathcal{D}^{\otimes k} \circ \mathcal P_\alpha \circ \mathcal{U}`,
where :math:`\mathcal{U}` is the unitary associated
to the input ``ideal_operation`` acting on :math:`k` qubits,
:math:`\mathcal{P}_\alpha` is a Pauli operation and
:math:`\mathcal{D}(\rho) = (1 - \epsilon) \rho + \epsilon I/2` is a
single-qubit depolarizing channel (:math:`\epsilon` is a simple function
of ``noise_level``).
More information about the quasi-probability representation for a
depolarizing noise channel can be found in:
:func:`represent_operation_with_global_depolarizing_noise`.
Args:
ideal_operation: The ideal operation (as a QPROGRAM) to represent.
noise_level: The noise level of each depolarizing channel.
Returns:
The quasi-probability representation of the ``ideal_operation``.
.. note::
The input ``ideal_operation`` is typically a QPROGRAM with a single
gate but could also correspond to a sequence of more gates.
This is possible as long as the unitary associated to the input
QPROGRAM, followed by a single final depolarizing channel, is
physically implementable.
.. [Temme2017] : Kristan Temme, Sergey Bravyi, Jay M. Gambetta,
"Error mitigation for short-depth quantum circuits,"
*Phys. Rev. Lett.* **119**, 180509 (2017),
(https://arxiv.org/abs/1612.02058).
"""
circ, in_type = convert_to_mitiq(ideal_operation)
qubits = circ.all_qubits()
if len(qubits) == 1:
return represent_operation_with_global_depolarizing_noise(
ideal_operation,
noise_level,
)
# The two-qubit case: tensor product of two depolarizing channels.
elif len(qubits) == 2:
q0, q1 = qubits
# Single-qubit representation coefficients.
epsilon = noise_level * 4 / 3
c_neg = -(1 / 4) * epsilon / (1 - epsilon)
c_pos = 1 - 3 * c_neg
imp_op_circuits = []
alphas = []
# The zero-pauli term in the linear combination
imp_op_circuits.append(circ)
alphas.append(c_pos * c_pos)
# The single-pauli terms in the linear combination
for qubit in qubits:
for pauli in [X, Y, Z]:
imp_op_circuits.append(circ + Circuit(pauli(qubit)))
alphas.append(c_neg * c_pos)
# The two-pauli terms in the linear combination
for pauli_0, pauli_1 in product([X, Y, Z], repeat=2):
imp_op_circuits.append(circ + Circuit(pauli_0(q0), pauli_1(q1)))
alphas.append(c_neg * c_neg)
else:
raise ValueError("Can only represent single- and two-qubit gates."
"Consider pre-compiling your circuit.")
# Convert back to input type
imp_op_circuits = [convert_from_mitiq(c, in_type) for c in imp_op_circuits]
# Build basis_expantion
expansion = {NoisyOperation(c): a for c, a in zip(imp_op_circuits, alphas)}
return OperationRepresentation(ideal_operation, expansion)
