NoiseModel

QuICT.core.noise.NoiseModel

NoiseModel(name: str = 'Noise Model', quantum_machine_info: VirtualQuantumMachine = None)

The Noise Model, which contains the QuantumNoiseErrors and can translate circuit with the given QuantumNoiseError.

Parameters:

• name (str, default: 'Noise Model' ) –

  The name of this NoiseModel. Defaults to "Noise Model".

• quantum_machine_info (VirtualQuantumMachine, default: None ) –

  The information about the quantum machine, can use those info to build NoiseModel for target machine. Defaults to None.

Source code in QuICT/core/noise/noise_model.py

def __init__(
    self,
    name: str = "Noise Model",
    quantum_machine_info: VirtualQuantumMachine = None
):
    """
    Args:
        name (str, optional): The name of this NoiseModel. Defaults to "Noise Model".
        quantum_machine_info (VirtualQuantumMachine, optional): The information about the quantum machine,
            can use those info to build NoiseModel for target machine. Defaults to None.
    """
    self._name = name
    self._vqm = quantum_machine_info

    self._error_by_gate = defaultdict(list)
    self._readout_errors = []

    if self._vqm is not None:
        self._build_nm_from_vqm()

add

add(noise: QuantumNoiseError, gates: Union[str, List[str]], qubits: Union[int, List[int]] = None)

Add noise which will affect target quantum gates with special qubits in the circuit.

Parameters:

• noise (QuantumNoiseError) –

  The noise error.

• gates (Union[str, List[str]]) –

  The affected quantum gates.

• qubits (Union[int, List[int]], default: None ) –

  The affected qubits, if None, same as add_noise_for_all_qubits. Defaults to None.

Source code in QuICT/core/noise/noise_model.py

def add(self, noise: QuantumNoiseError, gates: Union[str, List[str]], qubits: Union[int, List[int]] = None):
    """ Add noise which will affect target quantum gates with special qubits in the circuit.

    Args:
        noise (QuantumNoiseError): The noise error.
        gates (Union[str, List[str]]): The affected quantum gates.
        qubits (Union[int, List[int]], optional): The affected qubits, if None, same as add_noise_for_all_qubits.
            Defaults to None.
    """
    if qubits is None:
        self.add_noise_for_all_qubits(noise, gates)
        return

    # Input normalization
    qubits = self._qubits_normalize(qubits)
    gates = self._gates_normalize(noise, gates)

    # Add noise in the NoiseModel
    for gate in gates:
        self._error_by_gate[gate].append((noise, qubits))

add_noise_for_all_qubits

add_noise_for_all_qubits(noise: QuantumNoiseError, gates: Union[str, List[str]])

Add noise which will affect all qubits in the circuit.

Parameters:

• noise (QuantumNoiseError) –

  The noise error

• gates (Union[str, List[str]]) –

  The affected quantum gates.

Source code in QuICT/core/noise/noise_model.py

def add_noise_for_all_qubits(self, noise: QuantumNoiseError, gates: Union[str, List[str]]):
    """ Add noise which will affect all qubits in the circuit.

    Args:
        noise (QuantumNoiseError): The noise error
        gates (Union[str, List[str]]): The affected quantum gates.
    """
    # Input normalization
    gates = self._gates_normalize(noise, gates)

    # Add noise in the NoiseModel
    for gate in gates:
        self._error_by_gate[gate].append((noise, -1))

add_readout_error

add_readout_error(noise: ReadoutError, qubits: Union[int, List[int]])

Add Readout error in the noise model.

Example

1. Add 1-qubit Readout Error for all target qubits. noisemodel.add_readout_error(1-qubit ReadoutError, [0, 1, 2, etc])
2. Add multi-qubits Readout Error for specified qubits (the number of qubits equal to ReadoutError.qubits). noisemodel.add_readout_error(multi-qubits ReadoutError, [1, 3, etc])

Important

Supports to apply more than one Readout Error with the same target qubits, but do not support the combination of the Readout Error with the different qubits currently.

Parameters:

• noise (ReadoutError) –

  The Readout Error.

• qubits (Union[int, List[int]]) –

  The target qubits for the Readout error

Source code in QuICT/core/noise/noise_model.py

def add_readout_error(self, noise: ReadoutError, qubits: Union[int, List[int]]):
    """ Add Readout error in the noise model.

    Example:
        1. Add 1-qubit Readout Error for all target qubits.
            noisemodel.add_readout_error(1-qubit ReadoutError, [0, 1, 2, etc])
        2. Add multi-qubits Readout Error for specified qubits (the number of qubits equal to ReadoutError.qubits).
            noisemodel.add_readout_error(multi-qubits ReadoutError, [1, 3, etc])

    Important:
        Supports to apply more than one Readout Error with the same target qubits, but do not support the
        combination of the Readout Error with the different qubits currently.

    Args:
        noise (ReadoutError): The Readout Error.
        qubits (Union[int, List[int]]): The target qubits for the Readout error
    """
    assert isinstance(noise, ReadoutError), TypeError("NoiseModel.addreadouterror", "ReadoutError", type(noise))
    qubits = self._qubits_normalize(qubits)

    if noise.qubits > 1:
        assert noise.qubits == len(qubits), NoiseApplyError(
            "For multi qubits Readout Error, the given qubits' number should equal to the noise's qubit number."
        )

    self._readout_errors.append((noise, qubits))

apply_readout_error

apply_readout_error(qubit_indexes: Union[list, int], measured: int) -> int

Apply readout error to target qubits.

Parameters:

• qubit_indexes (Union(List, int) –

  The indexes of all measured qubits.

• measured (int) –

  the measured state of all measured qubits.

Source code in QuICT/core/noise/noise_model.py

def apply_readout_error(self, qubit_indexes: Union[list, int], measured: int) -> int:
    """ Apply readout error to target qubits.

    Args:
        qubit_indexes (Union(List, int)): The indexes of all measured qubits.
        measured (int): the measured state of all measured qubits.
    """
    if len(self._readout_errors) == 0:
        return measured

    if isinstance(qubit_indexes, int):
        return self._apply_re_for_single_qubit(qubit_indexes, measured)

    bits_measured = "{0:0b}".format(measured).zfill(len(qubit_indexes))
    bits_measured = [int(i) for i in bits_measured]
    for readouterror, qubits in self._readout_errors:
        if readouterror.qubits == 1:
            for q in qubits:
                if q in qubit_indexes:
                    truly_result = bits_measured[qubit_indexes.index(q)]
                    bits_measured[qubit_indexes.index(q)] = readouterror.apply_to_qubits(truly_result)
        else:
            all_qubits_measured = True
            target_qidx = []
            for q in qubits:
                if q not in qubit_indexes:
                    all_qubits_measured = False
                    break

                target_qidx.append(qubit_indexes.index(q))

            if not all_qubits_measured:
                continue

            truly_result = 0
            for tidx in target_qidx:
                truly_result <<= 1
                truly_result += int(bits_measured[tidx])

            noised_result = readouterror.apply_to_qubits(truly_result)
            for tidx in target_qidx[::-1]:
                bits_measured[tidx] = noised_result & 1
                noised_result >>= 1

    noise_state = 0
    for bm in bits_measured:
        noise_state <<= 1
        noise_state += bm

    return noise_state

is_ideal_model

is_ideal_model() -> bool

Validate it is an ideal(No noise) Quantum Machine Model or not.

Source code in QuICT/core/noise/noise_model.py

def is_ideal_model(self) -> bool:
    """ Validate it is an ideal(No noise) Quantum Machine Model or not. """
    if len(self._error_by_gate) + len(self._readout_errors) == 0:
        return True

    return False

transpile

transpile(circuit: Circuit, accumulated_mode: bool = False) -> Circuit

Apply all noise in the Noise Model to the given circuit, replaced related gate with the NoiseGate

Parameters:

• circuit (Circuit) –

  The given circuit.

• accumulated_mode (bool, default: False ) –

  Whether using accumulated mode to generate Noise Circuit.

Returns:

• Circuit ( Circuit ) –

  The noised circuit with.

Source code in QuICT/core/noise/noise_model.py

def transpile(self, circuit: Circuit, accumulated_mode: bool = False) -> Circuit:
    """ Apply all noise in the Noise Model to the given circuit, replaced related gate with the NoiseGate

    Args:
        circuit (Circuit): The given circuit.
        accumulated_mode (bool): Whether using accumulated mode to generate Noise Circuit.

    Returns:
        Circuit: The noised circuit with.
    """
    qubit_num = circuit.width() if isinstance(circuit, Circuit) else max(circuit.qubits) + 1
    noised_circuit = Circuit(qubit_num)
    for gate in circuit.flatten_gates():
        if isinstance(gate, BasicGate):
            gate_str = gate.type.name
            gate | noised_circuit
            if gate_str not in self._error_by_gate.keys():
                continue

            gate_args = gate.cargs + gate.targs
            noise_list = self._error_by_gate[gate_str]
            for noise, qubits in noise_list:
                # noise's qubit matched
                if qubits == -1 or (set(qubits) & set(gate_args)) == set(gate_args):
                    if accumulated_mode:
                        NoiseGate(gate, noise) | noised_circuit(gate_args)
                    else:
                        prob = random()
                        noise_gate = noise.prob_mapping_operator(prob)
                        if noise_gate is not None:
                            noise_gate | noised_circuit(gate_args)

    return noised_circuit