Support target-specific noise models

[perlinm]

See comment 1 and comment 2.

There are essentially two capabilities we want:

1. Allowing NoiseRule to depend on the target qubits of a gate (it currently only depends on the gate name).
2. Replacing, say, DEPOLARIZE2 and PAULI_CHANNEL_2 noise with appropriate DEPOLARIZE1 and PAULI_CHANNEL_1 instructions when only one qubit is immune to noise.

Option 2 is nice because it allows users to use built-in noise models while declaring only some qubits immune to noise. Option 1 is nice because it allows for, say, non-uniform noise models (e.g., if some qubits are noisier than others).

WARNING: When option 2 is implemented, we should make sure that nothing else in the repo breaks, because some code may assume that a two-qubit gate with one immune target gets no noise.

As a possible application of this PR, we can try to:

• Speed up AlphaSyndrome (see comment), basically undoing this change.

[perlinm]

@acasta-yhliu if you want to try and take this on, let's strategize a bit about implementation before you start making too many changes to noise_model.py.

[acasta-yhliu]

I'm currently reading noise_model.py, and I've found that noisy_operation is what I should change. First need to get rid off the testing:

        if immune_qubits and any(
            (
                target.is_qubit_target
                or target.is_x_target
                or target.is_y_target
                or target.is_z_target
            )
            and target.value in immune_qubits
            for target in targets
        ):
            return op, stim.Circuit()

[perlinm]

I agree that NoiseRule.noisy_operation is a good place to implement capability 2 (from the capabilities outlined here).

Capability 1 seems trickier to implement. Maybe we can define a subclass of NoiseRule (named, say, TargetedNoiseRule) that allows for more complicated noise rule specifications.

[acasta-yhliu]

The problem is to have a marginalization $p$ when truncating some of the qubits in the channel due to immunization. For readout, this is just $p\rightarrow p$. For depolarize(m) to depolarize (n), I think is $\frac{4^n-1}{4^m-1}$. But I think we need a general way to marginalize.

[perlinm]

What do you mean by a more general way to marginalize? I think it's fair to just discard all errors (Pauli strings) that affect immune qubits, which yields the factor of $\frac{4^n-1}{4^m-1}$ that you mention (though I think we only ever need (n,m)=(1,2) in practice).

The CORRELATED_ERROR instruction is much more complicated... I would be okay deferring the support of this instruction with immune qubits to a future issue.

[acasta-yhliu]

I suggest a rather dedicated design:

1. A TargetedNoiseRule that depends on the qubit index, it also has a marginalization switch to decide whether to marginalize or not when some qubits are immune.
2. The NoiseRule. However, the noisy_operation will be only implemented by the TargetNoiseRule, and:

class NoiseRule:
    ...
    def noisy_operation(
        self, op: stim.CircuitInstruction, *, immune_qubits: set[int] = set()
    ) -> tuple[stim.CircuitInstruction, stim.Circuit]:
        targets = op.targets_copy()
        return TargetedNoiseRule(targets, PARAMETERS).noisy_operation(op, immune_qubits=immune_qubits)

[acasta-yhliu]

What do you mean by a more general way to marginalize? I think it's fair to just discard all errors (Pauli strings) that affect immune qubits, which yields the factor of 4 n − 1 4 m − 1 that you mention (though I think we only ever need (n,m)=(1,2) in practice).

The CORRELATED_ERROR instruction is much more complicated... I would be okay deferring the support of this instruction with immune qubits to a future issue.

Oh, I mean the marginalization for not only depolarization but also other channels.

[perlinm]

I think I like the idea of NoiseRule.noisy_operation calling TargetedNoiseRule.noisy_operation, if that can be done cleanly.

Oh, I mean the marginalization for not only depolarization but also other channels.

As an example (maybe the only example, if we leave out CORRELATED_ERROR), if q1 is immune then I would replace

PAULI_CHANNEL_2(pix, piy, piz, pxi, pxx, pxy, pxz, pyi, pyx, pyy, pyz, pzi, pzx, pzy, pzz) q1 q2

by

PAULI_CHANNEL_1(pix, piy, piz) q2

One possibility to deal with marginalization is just to add a function that post-processes noise_after, possibly as late as here. It would loop over the stim.CircuitInstructions in the input circuit and apply error removal/rewrite rules.

[acasta-yhliu]

Seems the targeted noise rule would also introduce some interesting behaviors. For example, a noise rule targeting q1, q2 that applies depolarization 2q encounters an op only on q1 that wants the rule to operate. Do you want to apply DEPO-1Q to q2 only or just ignore it?

[perlinm]

I don't understand the example. If a targeted noise rule is essentially a map from an instruction (i.e., gate with choice of targets) to an error, then if it encounters any other instruction, it should not add any errors.

I think we're imagining different implementations of TargetedNoiseRule.

[acasta-yhliu]

I think the current NoiseRule class does not care what exact op it is when applying with noisy_operation. In my imagination, the TargetedNoiseRule is a more fine-grained control than immune_qubits. For example, you can set a TargetedNoiseRule with DEPOLARIZATION_2Q that only applies among $q_1\sim q_5$.

My concern is whether this is what you want, and if an instruction, for example, CX 2 10, is passed to the TargetedNoiseRule.noisy_operation through the NoiseModel (say I set clifford_2q_error = TargetedNoiseRule({"DEPOLARIZATION_2Q": 0.001}, {Q1 to Q5}) and the circuit contains a CX 2 10), what exact behavior should I expect rule.noisy_operation(CX 2 10) do to align with its definition?

[perlinm]

"What I want" is a clean API that allows fine-grained control over noise models. The exact behavior and implementation are up for debate 🙂

A naive version of what I have in mind at the moment may look like the following:

class TargetedNoiseRule(NoiseRule):
    def __init__(self, *, noisy_op: stim.CircuitInstruction, noise: stim.Circuit):
        self.noisy_op = noisy_op
        self.noise = noise

        # probably also allow + save readout/reset error inputs

    def is_targeted_noisy_op(self, op: stim.CircuitInstruction) -> bool:
        if op == self.noisy_op:
            return True
        # maybe still return True, depending on how we want to deal with op.tags and self.noisy_op.tags
        ...
        return False

    def noisy_operation(
        self, op: stim.CircuitInstruction, *, immune_qubits: set[int] = set()
    ) -> tuple[stim.CircuitInstruction, stim.Circuit]:
        if not self.is_targeted_noisy_op(op):
            return op, stim.Circuit()

        noisy_op = ...  # deal with reset/readout errors
        noise = ... # deal with immune_qubits
        return noisy_op, noise

Then...

1. The NoiseRule.noisy_operation method would remain nearly unchanged, except it might construct a new TargetedNoiseRule to deal with immune_qubits (or maybe not, if we factor out a method like def immunize_noise(noise: stim.Circuit, immune_qubits: set[int]) -> stim.Circuit: ...).
2. NoiseModel.get_noise_rule would look for (and if found, return) a matching TargetedNoiseRule before using a more generic NoiseRule (that is, before this line).

I make no claim that the above implementation is the cleanest, only that it captures the behavior I have in mind at the moment. For example, step (2) regarding NoiseModel.get_noise_rule seemingly needs to call TargetedNoiseRule.is_targeted_noisy_op, which is redundant with the call to TargetedNoiseRule.is_targeted_noisy_op in TargetedNoiseRule.noisy_operation.