# Source code for mitiq.pec.representations.biased_noise

```
# Copyright (C) Unitary Fund
#
# This source code is licensed under the GPL license (v3) found in the
# LICENSE file in the root directory of this source tree.
"""Function to generate representations with biased noise."""
import copy
from typing import List
from cirq import Circuit, Operation, X, Y, Z
from mitiq import QPROGRAM
from mitiq.interface.conversions import (
append_cirq_circuit_to_qprogram,
convert_to_mitiq,
)
from mitiq.pec import NoisyOperation, OperationRepresentation
[docs]
def represent_operation_with_local_biased_noise(
ideal_operation: QPROGRAM,
epsilon: float,
eta: float,
is_qubit_dependent: bool = True,
) -> OperationRepresentation:
r"""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 combined depolarizing and dephasing noise model
with a bias factor :math:`\eta` (see :cite:`Strikis_2021_PRXQuantum`)
and that the following noisy operations are implementable
:math:`\mathcal{O}_{\alpha} = \mathcal{D} \circ \mathcal P_\alpha`
where :math:`\mathcal{U}` is the unitary associated
to the input ``ideal_operation``,
:math:`\mathcal{P}_\alpha` is a Pauli operation and
.. math::
\mathcal{D}(\epsilon) = (1 - \epsilon)[\mathbb{1}] +
\epsilon(\frac{\eta}{\eta + 1} \mathcal{Z}
+ \frac{1}{3}\frac{1}{\eta + 1}(\mathcal{X} + \mathcal{Y}
+ \mathcal{Z}))
is the combined (biased) dephasing and depolarizing channel acting on a
single qubit. For multi-qubit operations, we use a noise channel that is
the tensor product of the local single-qubit channels.
Args:
ideal_operation: The ideal operation (as a QPROGRAM) to represent.
epsilon: The local noise severity (as a float) of the combined channel.
eta: The noise bias between combined dephasing and depolarizing
channels with :math:`\eta = 0` describing a fully depolarizing
channel and :math:`\eta = \infty` describing a fully dephasing
channel.
is_qubit_dependent: If True, the representation corresponds to the
operation on the specific qubits defined in `ideal_operation`.
If False, the representation is valid for the same gate even if
acting on different qubits from those specified in
`ideal_operation`.
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 backend which violates this assumption,
it remains a good approximation for small values of ``epsilon``.
.. 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 biased noise channel, is
physically implementable.
"""
circuit_copy = copy.deepcopy(ideal_operation)
converted_circ, _ = convert_to_mitiq(circuit_copy)
post_ops: List[List[Operation]]
qubits = converted_circ.all_qubits()
# Calculate coefficients in basis expansion in terms of eta and epsilon
a = 1 - epsilon
b = epsilon * (3 * eta + 1) / (3 * (eta + 1))
c = epsilon / (3 * (eta + 1))
alpha = (a**2 + a * b - 2 * c**2) / (
a**3 + a**2 * b - a * b**2 - 4 * a * c**2 - b**3 + 4 * b * c**2
)
beta = (-a * b - b**2 + 2 * c**2) / (
a**3 + a**2 * b - a * b**2 - 4 * a * c**2 - b**3 + 4 * b * c**2
)
gamma = -c / (a**2 + 2 * a * b + b**2 - 4 * c**2)
if len(qubits) == 1:
q = tuple(qubits)[0]
alphas = [alpha] + 2 * [gamma] + [beta]
post_ops = [[]] # for eta_1, 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
alphas = (
[alpha**2]
+ 2 * [alpha * gamma]
+ [alpha * beta]
+ 2 * [alpha * gamma]
+ [alpha * beta]
+ 2 * [gamma**2]
+ [beta * gamma]
+ 2 * [gamma**2]
+ 3 * [beta * gamma]
+ [beta**2]
)
post_ops = [[]] # for eta_1, 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 = [
append_cirq_circuit_to_qprogram(ideal_operation, Circuit(op))
for op in post_ops
]
# Build basis expansion.
noisy_operations = [NoisyOperation(c) for c in imp_op_circuits]
return OperationRepresentation(
ideal_operation, noisy_operations, alphas, is_qubit_dependent
)
```