Mq Noisy Simulation

from mindquantum.core.circuit.channel_adder import (
    DepolarizingChannelAdder,
    QubitNumberConstrain,
    MixerAdder,
    SequentialAdder,
)

# Different noise rates for 1-qubit vs 2-qubit gates
single_qubit_noise = MixerAdder(
    [
        DepolarizingChannelAdder(0.001, 1),
        QubitNumberConstrain(1),
    ]
)
two_qubit_noise = MixerAdder(
    [
        DepolarizingChannelAdder(0.01, 2),
        QubitNumberConstrain(2),
    ]
)
noise_model = SequentialAdder([single_qubit_noise, two_qubit_noise])

from mindquantum.core.circuit.channel_adder import ChannelAdderBase
from mindquantum.core.circuit import Circuit
from mindquantum.core.gates import DepolarizingChannel, Measure, NoiseGate


class QubitSpecificDepolarizing(ChannelAdderBase):
    """Apply different noise rates per qubit."""

    def __init__(self, qubit_id, p):
        self.qubit_id = qubit_id
        self.p = p
        super().__init__()

    def _accepter(self):
        return [lambda g: self.qubit_id in g.obj_qubits or self.qubit_id in g.ctrl_qubits]

    def _excluder(self):
        return [lambda g: isinstance(g, (Measure, NoiseGate))]

    def _handler(self, gate):
        return Circuit([DepolarizingChannel(self.p).on(self.qubit_id)])

from mindquantum.simulator import Simulator
from mindquantum.simulator.noise import NoiseBackend

# Create noisy simulator
noise_sim = Simulator(NoiseBackend("mqvector", n_qubits, noise_model))

# Use exactly like a normal simulator
result = noise_sim.sampling(circuit, shots=10000)

# Inspect the transformed circuit (with noise inserted)
noisy_circ = noise_sim.backend.transform_circ(circuit)
noisy_circ.svg()  # See where noise channels were added

sim = Simulator("mqmatrix", 4)
sim.apply_circuit(noisy_circuit)

# Density matrix operations
rho = sim.get_qs()  # Full density matrix
entropy = sim.entropy()  # Von Neumann entropy
purity = sim.purity()  # Tr(ρ²)
rho_sub = sim.get_partial_trace([0, 1])  # Trace out qubits 0,1

from mindquantum.core.circuit import Circuit
from mindquantum.core.gates import RY, CNOT, DepolarizingChannel
from mindquantum.core.operators import QubitOperator, Hamiltonian
from mindquantum.simulator import Simulator
import numpy as np
from scipy.optimize import minimize

# Noisy ansatz
ansatz = Circuit()
ansatz += RY("a0").on(0)
ansatz += DepolarizingChannel(0.005).on(0)
ansatz += RY("a1").on(1)
ansatz += DepolarizingChannel(0.005).on(1)
ansatz += CNOT.on(1, 0)
ansatz += DepolarizingChannel(0.01).on(0)
ansatz += DepolarizingChannel(0.01).on(1)

ham = Hamiltonian(QubitOperator("Z0 Z1") + QubitOperator("X0", 0.5))
sim = Simulator("mqvector", 2)
grad_ops = sim.get_expectation_with_grad(ham, ansatz)


def cost(params):
    f, _ = grad_ops(params)
    return np.real(f)[0, 0]


# Example gradient-free SciPy optimizer
result = minimize(cost, np.zeros(2), method="Nelder-Mead")
print(f"Noisy VQE energy: {result.fun:.6f}")