1. Noise¶

class AdditionNoiseBase(NoiseBase):
    """
    Base class for noise added before the operation
    """

    def __init__(self, noise_parameters=None):
        if noise_parameters is None or type(noise_parameters) is not dict:
            noise_parameters = {"After gate": True}
        else:
            if "After gate" not in noise_parameters.keys():
                noise_parameters["After gate"] = True

        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noisy gate to the state

        :param state: the state
        :type state: QuantumState
        :param n_quantum: number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where the noise is applied
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """

        raise NotImplementedError("Base class is abstract.")

class AmplitudeDampingNoise(AdditionNoiseBase):
    """
    Amplitude damping noise described by a depolarizing probability

    """

    def __init__(self, damping_probability):
        """
        Construct an amplitude damping noise model

        :param damping_probability: the dampening probability between 0 and 1
        :type damping_probability: float
        """
        noise_parameters = {"damping_probability": damping_probability}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noisy gate to the state representations of state

        :param state: the state
        :type state: QuantumState
        :param n_quantum: number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where the noise is applied
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            damping_prob = self.noise_parameters["damping_probability"]
            if damping_prob == 0.0:
                return
            single_qubit_kraus = dmf.amplitude_damping_operators(damping_prob)
            kraus_ops_iter = itertools.combinations(single_qubit_kraus, len(reg_list))
            kraus_ops = []
            for kraus_op in kraus_ops_iter:
                kraus_ops.append(
                    dmf.get_multi_qubit_gate(n_quantum, reg_list, kraus_op)
                )

            state_rep.apply_channel(kraus_ops)

        elif isinstance(state_rep, Stabilizer):
            # TODO: Find the correct representation for Stabilizer backend
            raise NotImplementedError(
                "AmplitudeDamping not implemented for stabilizer representation"
            )
        elif isinstance(state_rep, Graph):
            # TODO: Implement this for Graph backend
            raise NotImplementedError(
                "AmplitudeDamping not implemented for graph representation"
            )
        else:
            raise TypeError("Backend type is not supported.")

class CoherentUnitaryError(AdditionNoiseBase):
    """
    Coherent unitary error described by a single unitary

    # TODO: implement this error model
    """

    def __init__(self, unitary):
        """
        Construct a coherent unitary error described by a single unitary

        :param unitary: a unitary that specified the error
        :type unitary: numpy.nadrray or str
        :return: nothing
        :rtype: None
        """
        noise_parameters = {"Unitary": unitary}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply this noise model to a quantum state

        :param state: a quantum state
        :type state: QuantumState
        :param n_quantum: the number of qubits
        :type n_quantum: int
        :param reg_list: a list of register numbers
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            # TODO: Implement this for DensityMatrix backend
            raise NotImplementedError(
                "CoherentUnitaryError not implemented for density matrix representation"
            )
        elif isinstance(state_rep, Stabilizer):
            # TODO: Find the correct representation for Stabilizer backend
            raise NotImplementedError(
                "CoherentUnitaryError not implemented for stabilizer representation"
            )
        elif isinstance(state_rep, Graph):
            # TODO: Implement this for Graph backend
            raise NotImplementedError(
                "CoherentUnitaryError not implemented for graph representation"
            )
        else:
            raise TypeError("Backend type is not supported.")

class DepolarizingNoise(AdditionNoiseBase):
    """
    Depolarizing noise described by a depolarizing probability

    """

    def __init__(self, depolarizing_prob):
        """
        Construct a depolarizing noise model

        :param depolarizing_prob: the depolarizing probability
        :type depolarizing_prob: float
        """
        noise_parameters = {"Depolarizing probability": depolarizing_prob}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply a depolarizing channel to the state, with probability :math:`p`.
        The form of the channel (as Kraus operators) is,

        :math:`\\rho \\to (1-p) \\rho + \\frac{p}{4^n - 1} \\sum_i P_i \\rho P_i`

        where :math:`P_i` are the Pauli strings.

        :param state: the state
        :type state: QuantumState
        :param n_quantum: number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where the noise is applied
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        depolarizing_prob = self.noise_parameters["Depolarizing probability"]
        n_kraus = 4 ** len(reg_list)
        factors = np.array(
            [1 - depolarizing_prob]
            + (n_kraus - 1) * [depolarizing_prob / (n_kraus - 1)]
        )

        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            single_qubit_kraus = [
                dmf.identity(),
                dmf.sigmax(),
                dmf.sigmay(),
                dmf.sigmaz(),
            ]
            kraus_ops_iter = itertools.product(single_qubit_kraus, repeat=len(reg_list))

            kraus_ops = []

            for i, kraus_op in enumerate(kraus_ops_iter):
                kraus_ops.append(
                    np.sqrt(factors[i])
                    * dmf.get_multi_qubit_gate(n_quantum, reg_list, kraus_op)
                )
            state_rep.apply_channel(kraus_ops)

        elif isinstance(state_rep, Stabilizer) or isinstance(
            state_rep, MixedStabilizer
        ):
            if not isinstance(state_rep, MixedStabilizer):
                rep_data = MixedStabilizer([(1.0, state_rep.data)])
                state.rep_data = rep_data

            original_prob = state_rep.probability
            mixture = []
            single_qubit_trans = [
                transform.identity,
                transform.x_gate,
                transform.y_gate,
                transform.z_gate,
            ]

            trans_iter = itertools.product(single_qubit_trans, repeat=len(reg_list))
            trans_iter = list(trans_iter)

            for p_i, tableau_i in state_rep.mixture:
                for k in range(len(trans_iter)):
                    if p_i * factors[k] > 0:
                        new_tableau_i = tableau_i.copy()
                        for pauli_j, qubit_position in zip(trans_iter[k], reg_list):
                            new_tableau_i = pauli_j(new_tableau_i, qubit_position)
                        mixture.append((p_i * factors[k], new_tableau_i))

            if not np.isclose(sum([pi for pi, ti in mixture]), original_prob):
                raise ValueError(
                    f"Probability is not the same as the original probability of the mixture, \
                        which is {original_prob}. P = {sum([pi for pi, ti in mixture])}, \
                        lam={depolarizing_prob} | Reg list {reg_list}"
                )

            state_rep.mixture = mixture
            if REDUCE_STABILIZER_MIXTURE:
                state_rep.reduce()

        elif isinstance(state_rep, Graph):
            # TODO: Implement this for Graph backend
            raise NotImplementedError(
                "DepolarizingNoise not implemented for graph representation"
            )
        else:
            raise TypeError(f"Backend type {type(state_rep)} is not supported.")

class GeneralKrausError(AdditionNoiseBase):
    """
    A general error described by Kraus operators

    This error may only work for the DensityMatrix backend.

    # TODO: Implement this noise model by figuring out how to pass parameters
    """

    def __init__(self, kraus_ops):
        """
        Construct a GeneralKrausError object

        :param kraus_ops: a list of Kraus operators
        :type kraus_ops: list
        :return: nothing
        :rtype: None
        """
        noise_parameters = {"Kraus": kraus_ops}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noise model to the state representation state_rep

        :param state: a quantum state
        :type state: QuantumState
        :param n_quantum: the number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where non-identity gates are applied
        :type reg_list: list[int]
        :return: nothing
        """
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            kraus_ops = self.get_backend_dependent_noise(state_rep, n_quantum, reg_list)
            state_rep.apply_channel(kraus_ops)
        elif isinstance(state_rep, Stabilizer):
            raise NotImplementedError(
                "GeneralKrausError not implemented (and not compatible) for stabilizer representation"
            )
        elif isinstance(state_rep, Graph):
            raise NotImplementedError(
                "GeneralKrausError not implemented (and not compatible) for graph representation"
            )
        else:
            raise TypeError("Backend type is not supported.")

class HadamardPerturbedError(OneQubitGateReplacement):
    """
    A noisy version of Hadamard gate is used to replace the original gate.
    The noise is specified by the perturbation angles that deviate from
    the original parameters :math:`(\\pi/2, 0, \\pi)`.
    """

    def __init__(self, theta_pert, phi_pert, lam_pert):
        """
        Construct a HadamardPerturbedError object

        :param theta_pert: the perturbation added to the theta angle
        :type theta_pert: float
        :param phi_pert: the perturbation added to the phi angle
        :type phi_pert: float
        :param lam_pert: the perturbation added to the lambda angle
        :type lam_pert: float
        :return: nothing
        :rtype: None
        """

        super().__init__(
            dmf.parameterized_one_qubit_unitary(
                np.pi / 2 + theta_pert, phi_pert, np.pi + lam_pert
            )
        )
        self.noise_parameters["Perturbation"] = (theta_pert, phi_pert, lam_pert)
        self.noise_parameters["Original parameters"] = (np.pi / 2, 0, np.pi)

class LocalCliffordError(AdditionNoiseBase):
    """
    A local Clifford error specified by a list of one-qubit unitary that consists of the local Clifford

    """

    def __init__(self, local_clifford):
        """
        Construct a one-qubit Clifford gate error

        :param local_clifford: a list of elementary gates that compose the local Clifford gate
        :type local_clifford: list[str]
        :return: nothing
        :rtype: None
        """
        noise_parameters = {"Local Clifford error": local_clifford}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noise model to a quantum state

        :param state: a quantum state
        :type state: QuantumState
        :param n_quantum: the number of qubits
        :type n_quantum: int
        :param reg_list: a list of register numbers
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        clifford_error = self.noise_parameters["Local Clifford error"]
        assert type(clifford_error) is list
        assert len(reg_list) == 1
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            unitary = np.eye(2**n_quantum)
            for gate in clifford_error[::-1]:
                if gate.lower() == "sigmax":
                    unitary = (
                        dmf.get_one_qubit_gate(n_quantum, reg_list[0], dmf.sigmax())
                        @ unitary
                    )
                elif gate.lower() == "sigmay":
                    unitary = (
                        dmf.get_one_qubit_gate(n_quantum, reg_list[0], dmf.sigmay())
                        @ unitary
                    )
                elif gate.lower() == "sigmaz":
                    unitary = (
                        dmf.get_one_qubit_gate(n_quantum, reg_list[0], dmf.sigmaz())
                        @ unitary
                    )
                elif gate.lower() == "hadamard":
                    unitary = (
                        dmf.get_one_qubit_gate(n_quantum, reg_list[0], dmf.hadamard())
                        @ unitary
                    )
                elif gate.lower() == "phase":
                    unitary = (
                        dmf.get_one_qubit_gate(n_quantum, reg_list[0], dmf.phase())
                        @ unitary
                    )
                elif gate.lower() == "identity":
                    pass
                else:
                    raise ValueError("Wrong description of a local Clifford gate.")
            state_rep.apply_unitary(unitary)
        elif isinstance(state_rep, Stabilizer):
            # TODO: Implement this for the Stabilizer backend
            raise NotImplementedError(
                "Local Clifford error has not been implemented for stabilizer backend"
            )
        elif isinstance(state_rep, Graph):
            # TODO: Implement this for the Graph backend
            raise NotImplementedError(
                "Local Clifford error has not been implemented for stabilizer backend"
            )
        else:
            raise TypeError("Backend type is not supported.")

class MeasurementError(NoiseBase):
    """
    a measurement error described by a conditional probability distribution

     # TODO: implement this error model
    """

    def __init__(self, prob_dist):
        """
        Construct a MeasurementError object

        :param prob_dist: a :math:`2 \\times 2` matrix to describe the conditional probability of
            flipping measurement outcomes
        :type prob_dist: numpy.ndarray
        :return: nothing
        :rtype: None
        """
        noise_parameters = {"Conditional probability": prob_dist}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noise to the state representation state_rep

        :param state: the quantum state
        :type state: QuantumState
        :param n_quantum: number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where the noise is applied
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            # TODO: Implement this for DensityMatrix backend
            raise NotImplementedError(
                "MeasurementError not implemented for density matrix representation"
            )
        elif isinstance(state_rep, Stabilizer):
            # TODO: Find the correct representation for Stabilizer backend
            raise NotImplementedError(
                "MeasurementError not implemented for stabilizer representation"
            )
        elif isinstance(state_rep, Graph):
            # TODO: Implement this for Graph backend
            raise NotImplementedError(
                "MeasurementError not implemented for graph representation"
            )
        else:
            raise TypeError("Backend type is not supported.")

class MixedUnitaryError(AdditionNoiseBase):
    """
    Mixed unitary error, described by an ensemble of unitary operations

    TODO: implement this error model
    """

    def __init__(self, unitaries_list, prob_list):
        """
        Construct a MixedUnitaryError object

        :param unitaries_list: a list of unitary operations
        :type unitaries_list: list[numpy.ndarray]
        :param prob_list: the corresponding probability distribution for the unitaries
        :type prob_list: list[float]
        """
        noise_parameters = {"Unitaries": unitaries_list, "Probabilities": prob_list}
        super().__init__(noise_parameters)

    def apply(self, state: QuantumState, n_quantum, reg_list):
        """
        Apply the noise to the state representation state_rep

        :param state: the state
        :type state: QuantumState
        :param n_quantum: number of qubits
        :type n_quantum: int
        :param reg_list: a list of registers where the noise is applied
        :type reg_list: list[int]
        :return: nothing
        :rtype: None
        """
        state_rep = state.rep_data
        if isinstance(state_rep, DensityMatrix):
            # TODO: Implement this for DensityMatrix backend
            raise NotImplementedError(
                "MixedUnitary not implemented for DensityMatrix representation"
            )
        elif isinstance(state_rep, Stabilizer):
            # TODO: Find the correct representation for Stabilizer backend
            raise NotImplementedError(
                "MixedUnitary not implemented for Stabilizer representation"
            )
        elif isinstance(state_rep, Graph):
            # TODO: Implement this for Graph backend
            raise NotImplementedError(
                "MixedUnitary not implemented for graph representation"
            )
        else:
            raise TypeError("Backend type is not supported.")