Noise Model Theory

Theoretical foundations of quantum noise modeling, including CPTP maps, Kraus representations, quantum error channels, and practical noise considerations for NISQ devices. This guide connects the mathematical formalism to pyqpanda3's noise simulation capabilities.

---

The Need for Noise Modeling

Real quantum computers operate in noisy environments. Unlike classical bits, qubits are fragile quantum systems that lose their quantum properties through interactions with the environment. Noise modeling is essential for:

1. Accurate simulation: Predicting real hardware behavior before running experiments
2. Error mitigation: Designing strategies to reduce the impact of noise
3. Error correction: Understanding the noise to build appropriate quantum error-correcting codes
4. Benchmarking: Comparing hardware performance against theoretical noise models

In pyqpanda3, the NoiseModel class and associated error channels provide a comprehensive framework for noisy simulation.

---

Quantum Operations as Maps

Density Matrix Formalism

Before discussing noise, we need the density matrix formalism for describing quantum states:

Pure state: A state that can be written as a ket $|\psi ⟩$. Its density matrix is:

$$\rho =|\psi ⟩⟨\psi |$$

Mixed state: A statistical mixture of pure states $\{p_i,|{\psi }_i⟩\}$:

$$\rho =\sum _i{p}_i|{\psi }_i⟩⟨{\psi }_i|$$

where $p_i\ge 0$ and $\sum _i{p}_i=1$.

Properties of a valid density matrix:

• Hermitian: $\rho ={\rho }^{†}$
• Positive semi-definite: $\rho \ge 0$ (all eigenvalues $\ge 0$)
• Unit trace: $\text{Tr}(\rho )=1$

Pure vs. Mixed States

A state is pure if and only if $\text{Tr}({\rho }^2)=1$, and mixed if $\text{Tr}({\rho }^2)<1$. The purity $\gamma =\text{Tr}({\rho }^2)$ quantifies how "pure" a state is:

• $\gamma =1$: pure state
• $1/d<\gamma <1$: mixed state ($d$ is the Hilbert space dimension)
• $\gamma =1/d$: maximally mixed state $\rho =I/d$

pyqpanda3's DensityMatrix class provides the purity() method for this calculation.

---

Completely Positive Trace-Preserving (CPTP) Maps

Definition

A quantum channel (noise model) is mathematically described by a Completely Positive Trace-Preserving (CPTP) map $\mathcal{E}$ that transforms input density matrices to output density matrices:

$$\mathcal{E}:{\rho }_{\text{in}}\mapsto {\rho }_{\text{out}}$$

The two requirements are:

Complete Positivity (CP): For any auxiliary system of any dimension $d_A$, the extended map $(\mathcal{E}\otimes I_{d_A})$ maps positive operators to positive operators:

$$\rho \ge 0⟹(\mathcal{E}\otimes I)(\rho )\ge 0\mathrm{\forall }\text{ extensions}$$

Complete positivity is stronger than mere positivity — a map that is positive but not completely positive can produce unphysical results when applied to a subsystem of an entangled state.

Trace Preservation (TP): The trace of the density matrix is preserved:

$$\text{Tr}(\mathcal{E}(\rho ))=\text{Tr}(\rho )=1$$

This ensures total probability is conserved.

Why CPTP?

CPTP maps are the correct mathematical framework for quantum noise because:

1. Physicality: CPTP maps are exactly the set of transformations that can occur in nature (by Stinespring's dilation theorem, any CPTP map can be realized by unitary evolution on a larger system)
2. Composability: The composition of two CPTP maps is also CPTP — noise models can be chained
3. Convexity: A probabilistic mixture of CPTP maps is CPTP — different noise sources combine correctly

Stinespring Dilation

Every CPTP map $\mathcal{E}$ on a system ${\mathcal{H}}_S$ can be realized as a unitary evolution on a larger system:

$$\mathcal{E}(\rho )={\text{Tr}}_E[U_{SE}(\rho \otimes |e_0⟩⟨e_0|)U_{SE}^{†}]$$

where $U_{SE}$ is a unitary on the joint system-environment Hilbert space ${\mathcal{H}}_S\otimes {\mathcal{H}}_E$, $|e_0⟩$ is a fixed environment state, and ${\text{Tr}}_E$ is the partial trace over the environment.

This means all physical noise can be understood as unitary evolution with an unobserved environment — the randomness comes from tracing out (ignoring) the environment degrees of freedom.

graph LR
    subgraph "Stinespring Dilation"
        S["System ρ"] --> US["U_SE"]
        E["Environment |e₀⟩"] --> US
        US --> SE["System ⊗ Environment"]
        SE --> TrE["Tr_E (trace out)"]
        TrE --> Out["ρ_out = ℰ(ρ)"]
    end

    style S fill:#e3f2fd,stroke:#1565c0
    style E fill:#fff3e0,stroke:#e65100
    style Out fill:#c8e6c9,stroke:#2e7d32

---

Kraus Representation

Operator-Sum Representation

The most intuitive representation of a CPTP map is the Kraus (operator-sum) representation:

$$\mathcal{E}(\rho )=\sum _i{K}_i\rho K_i^{†}$$

where the Kraus operators $\{K_i\}$ satisfy the completeness relation:

$$\sum _i{K}_i^{†}{K}_i=I$$

This condition ensures trace preservation:

$$\text{Tr}(\mathcal{E}(\rho ))=\text{Tr}\left(\sum _i{K}_i\rho K_i^{†}\right)=\text{Tr}\left(\rho \sum _i{K}_i^{†}{K}_i\right)=\text{Tr}(\rho )=1$$

Properties of Kraus Representations

1. Non-uniqueness: The same channel can have different Kraus representations related by unitary mixing: $K_i^{\prime }=\sum _j{u}_{ij}{K}_j$ where $U=(u_{ij})$ is unitary.

2. Minimum number: The minimum number of Kraus operators needed is the Choi rank of the channel. For a qubit channel, this is between 1 (unitary) and 4 (completely depolarizing).

3. Single Kraus operator: If there is only one Kraus operator, the channel is unitary: $\mathcal{E}(\rho )=U\rho U^{†}$.

Kraus Operators for Common Channels

Channel	Number of Kraus Ops	Kraus Operators
Unitary ($U$)	1	$K_0=U$
Bit Flip	2	$K_0=\sqrt{1-p}I$, $K_1=\sqrt{p}X$
Phase Flip	2	$K_0=\sqrt{1-p}I$, $K_1=\sqrt{p}Z$
Depolarizing	4	$K_0=\sqrt{1-3p/4}I$, $K_{1,2,3}=\sqrt{p/4}\{X,Y,Z\}$
Amplitude Damping	2	$K_0=\left(\begin{array}{cc}1& 0\\ 0& \sqrt{1-\gamma }\end{array}\right)$, $K_1=\left(\begin{array}{cc}0& \sqrt{\gamma }\\ 0& 0\end{array}\right)$
Phase Damping	2	$K_0=\left(\begin{array}{cc}1& 0\\ 0& \sqrt{1-\lambda }\end{array}\right)$, $K_1=\left(\begin{array}{cc}0& 0\\ 0& \sqrt{\lambda }\end{array}\right)$

pyqpanda3's Kraus class in the quantum_info module represents channels in this form. Channels can also be represented as Chi, Choi, SuperOp, or PTM, all of which are interconvertible.

---

Quantum Error Channels

Depolarizing Channel

The depolarizing channel is the most commonly used noise model. With probability $p$, the state is replaced by the maximally mixed state $I/2$:

$${\mathcal{E}}_{\text{depol}}(\rho )=(1-p)\rho +p\frac{I}{2}$$

An equivalent form expanded in the Pauli basis is:

$${\mathcal{E}}_{\text{depol}}(\rho )=(1-\frac{3p}{4})\rho +\frac{p}{4}(X\rho X+Y\rho Y+Z\rho Z)$$

Kraus operators (4 operators):

$$K_0=\sqrt{1-\frac{3p}{4}}I,K_1=\sqrt{\frac{p}{4}}X,K_2=\sqrt{\frac{p}{4}}Y,K_3=\sqrt{\frac{p}{4}}Z$$

Properties:

• Symmetric: treats all three axes equally
• Shrinks the Bloch vector uniformly: $\overrightarrow{r}\to (1-p)\overrightarrow{r}$
• Often used as a worst-case noise model
• $p=1$ gives the completely random state $I/2$

Amplitude Damping Channel

The amplitude damping channel models energy dissipation — the decay of an excited state $|1⟩$ to the ground state $|0⟩$:

$${\mathcal{E}}_{\text{AD}}(\rho )=K_0\rho K_0^{†}+K_1\rho K_1^{†}$$

Kraus operators:

$$K_0=\left(\begin{array}{cc}1& 0\\ 0& \sqrt{1-\gamma }\end{array}\right),K_1=\left(\begin{array}{cc}0& \sqrt{\gamma }\\ 0& 0\end{array}\right)$$

where $\gamma \in [0,1]$ is the damping probability (related to $T_1$ relaxation time).

Action on basis states:

$$|0⟩⟨0|\to |0⟩⟨0|\text{(ground state unchanged)}$$$$|1⟩⟨1|\to (1-\gamma )|1⟩⟨1|+\gamma |0⟩⟨0|\text{(decay to ground)}$$

Properties:

• Non-unital: $\mathcal{E}(I)\ne I$ (the channel doesn't preserve the identity)
• Drives states toward $|0⟩$
• Models spontaneous emission, $T_1$ decay
• $\gamma =0$: identity (no damping); $\gamma =1$: complete relaxation to $|0⟩$

Connection to $T_1$ time: For a gate of duration $t_g$:

$$\gamma =1-e^{-t_g/T_1}$$

Phase Damping (Dephasing) Channel

The phase damping channel models loss of phase coherence without energy loss:

$${\mathcal{E}}_{\text{PD}}(\rho )=K_0\rho K_0^{†}+K_1\rho K_1^{†}$$

Kraus operators:

$$K_0=\left(\begin{array}{cc}1& 0\\ 0& \sqrt{1-\lambda }\end{array}\right),K_1=\left(\begin{array}{cc}0& 0\\ 0& \sqrt{\lambda }\end{array}\right)$$

where $\lambda \in [0,1]$ is the dephasing probability.

Equivalent form using Pauli Z:

$${\mathcal{E}}_{\text{PD}}(\rho )=(1-\frac{p}{2})\rho +\frac{p}{2}Z\rho Z$$

where $p=1-e^{-t_g/T_{\varphi }}$.

Properties:

• Unital: $\mathcal{E}(I)=I$
• Preserves computational basis: diagonal elements unchanged
• Suppresses off-diagonal elements (coherences): ${\rho }_{01}\to \sqrt{1-\lambda }{\rho }_{01}$
• Models $T_2$ decoherence
• $\lambda =0$: identity; $\lambda =1$: complete dephasing (classical mixture)

Connection to $T_2$ time:

$$\frac{1}{T_2}=\frac{1}{2T_1}+\frac{1}{T_{\varphi }}$$

where $T_{\varphi }$ is the pure dephasing time.

Bit Flip Channel

The bit flip channel randomly applies an $X$ gate:

$${\mathcal{E}}_{\text{BF}}(\rho )=(1-p)\rho +pX\rho X$$

Kraus operators: $K_0=\sqrt{1-p}I$, $K_1=\sqrt{p}X$

Bloch sphere action: Flips the $z$-component with probability $p$: $r_z\to (1-2p)r_z$, $r_y\to (1-2p)r_y$, $r_x$ unchanged.

Connection: Equivalent to phase flip in the Hadamard basis: $H\cdot {\mathcal{E}}_{\text{BF}}\cdot H={\mathcal{E}}_{\text{PF}}$.

Phase Flip Channel

The phase flip channel randomly applies a $Z$ gate:

$${\mathcal{E}}_{\text{PF}}(\rho )=(1-p)\rho +pZ\rho Z$$

Kraus operators: $K_0=\sqrt{1-p}I$, $K_1=\sqrt{p}Z$

Bloch sphere action: $r_z$ unchanged, $r_x\to (1-2p)r_x$, $r_y\to (1-2p)r_y$.

Bit-Phase Flip Channel

The bit-phase flip channel randomly applies a $Y$ gate (simultaneous bit and phase flip):

$${\mathcal{E}}_{\text{BPF}}(\rho )=(1-p)\rho +pY\rho Y$$

Kraus operators: $K_0=\sqrt{1-p}I$, $K_1=\sqrt{p}Y$

Note: $Y=iXZ$, so this is a combined bit flip and phase flip (with an additional global phase).

Pauli Noise Channel

The general Pauli noise channel applies random Pauli operators with individual probabilities:

$${\mathcal{E}}_{\text{Pauli}}(\rho )=p_I\rho +p_{X}X\rho X+p_{Y}Y\rho Y+p_{Z}Z\rho Z$$

where $p_I+p_X+p_Y+p_Z=1$.

This is the most general single-qubit Pauli channel and includes bit flip, phase flip, and depolarizing as special cases.

Thermal Relaxation Channel

The thermal relaxation channel models the combined effect of $T_1$ (amplitude damping) and $T_2$ (dephasing) processes over a gate duration $t$:

$${\mathcal{E}}_{\text{thermal}}(\rho )=E_0\rho E_0^{†}+E_1\rho E_1^{†}+E_2\rho E_2^{†}$$

where the Kraus operators depend on the relaxation times $T_1$, $T_2$, and the gate time $t$:

$$p_{\text{reset}}=1-e^{-t/T_1}$$$$p_{\text{dephasing}}=1-e^{-t/T_2}$$

This channel is essential for realistic simulations of superconducting qubit hardware.

Summary: Error Channel Comparison

Channel	Parameter	Unital?	Physical Origin
Depolarizing	$p\in [0,1]$	Yes	Generic noise
Amplitude Damping	$\gamma \in [0,1]$	No	$T_1$ relaxation
Phase Damping	$\lambda \in [0,1]$	Yes	$T_2$ dephasing
Bit Flip	$p\in [0,0.5]$	Yes	$X$ errors
Phase Flip	$p\in [0,0.5]$	Yes	$Z$ errors
Bit-Phase Flip	$p\in [0,0.5]$	Yes	$Y$ errors
Pauli Noise	$p_I,p_X,p_Y,p_Z$	Yes	General Pauli errors
Thermal Relaxation	$T_1,T_2,t$	No	Combined relaxation

graph TD
    All["All Error Channels"] --> Unital["Unital Channels"]
    All --> NonUnital["Non-Unital Channels"]

    Unital --> PauliCh["Pauli Channels"]
    PauliCh --> BF["Bit Flip"]
    PauliCh --> PF["Phase Flip"]
    PauliCh --> BPF["Bit-Phase Flip"]
    PauliCh --> Depol["Depolarizing"]
    PauliCh --> General["General Pauli"]

    Unital --> PD["Phase Damping"]

    NonUnital --> AD["Amplitude Damping"]
    NonUnital --> TR["Thermal Relaxation"]
    AD --> TR

    style Unital fill:#e3f2fd,stroke:#1565c0
    style NonUnital fill:#fff3e0,stroke:#e65100

---

Quantum Channel Representations

A single quantum channel can be represented in multiple mathematically equivalent ways. pyqpanda3 supports five representations, all interconvertible:

Kraus Representation

$$\mathcal{E}(\rho )=\sum _i{K}_i\rho K_i^{†}$$

Most intuitive; directly shows the physical operations.

Superoperator (Liouville) Representation

The channel is represented as a $d^2\times d^2$ matrix $\mathcal{S}$ acting on vectorized density matrices:

$$\text{vec}(\mathcal{E}(\rho ))=\mathcal{S}\cdot \text{vec}(\rho )$$

where $\text{vec}(\cdot )$ stacks matrix columns. In pyqpanda3, this is the SuperOp class.

Chi Matrix Representation

The channel is expanded in the Pauli basis:

$$\mathcal{E}(P_j)=\sum _i{\chi }_{ij}{P}_i$$

The $\chi$ matrix (not to be confused with the Choi matrix) is the Pauli-basis representation. In pyqpanda3, this is the Chi class.

Choi Matrix Representation

The Choi matrix is defined as:

$$J(\mathcal{E})=(\mathcal{E}\otimes I)(|\mathrm{\Omega }⟩⟨\mathrm{\Omega }|)$$

where $|\mathrm{\Omega }⟩=\sum _i|i⟩\otimes |i⟩$ is the maximally entangled state. The channel is CPTP if and only if $J(\mathcal{E})\ge 0$ (positive semidefinite) and ${\text{Tr}}_1(J)=I$ (partial trace condition). In pyqpanda3, this is the Choi class.

Pauli Transfer Matrix (PTM)

The PTM represents the channel's action on the generalized Pauli basis:

$$R_{ij}=\frac{1}{d}\text{Tr}(P_i\mathcal{E}(P_j))$$

where $\{P_i\}$ are normalized Pauli operators. The PTM is a real matrix for Hermiticity-preserving channels. In pyqpanda3, this is the PTM class.

Conversion Between Representations

All five representations are interconvertible in pyqpanda3 by constructing one from another:

graph TD
    Kraus["Kraus"]
    SuperOp["SuperOp"]
    Chi["Chi"]
    Choi["Choi"]
    PTM["PTM"]

    Kraus -->|constructor| SuperOp
    Kraus -->|constructor| Chi
    Kraus -->|constructor| Choi
    Kraus -->|constructor| PTM

    SuperOp -->|constructor| Kraus
    SuperOp -->|constructor| Chi
    SuperOp -->|constructor| Choi
    SuperOp -->|constructor| PTM

    Chi -->|constructor| Kraus
    Chi -->|constructor| SuperOp
    Chi -->|constructor| Choi
    Chi -->|constructor| PTM

    Choi -->|constructor| Kraus
    Choi -->|constructor| SuperOp
    Choi -->|constructor| Chi
    Choi -->|constructor| PTM

    PTM -->|constructor| Kraus
    PTM -->|constructor| SuperOp
    PTM -->|constructor| Chi
    PTM -->|constructor| Choi

    style Kraus fill:#e3f2fd,stroke:#1565c0
    style SuperOp fill:#c8e6c9,stroke:#2e7d32
    style Chi fill:#fff3e0,stroke:#e65100
    style Choi fill:#f3e5f5,stroke:#9c27b0
    style PTM fill:#ffebee,stroke:#c62828

---

Noise in NISQ Devices

Characteristics of NISQ Noise

Current Noisy Intermediate-Scale Quantum (NISQ) devices exhibit several types of noise:

1. Gate Errors: Imperfect gate implementation causes unitary errors and over/under-rotation:

• Single-qubit gate error rate: $\sim {10}^{-4}$ to ${10}^{-3}$
• Two-qubit gate error rate: $\sim {10}^{-3}$ to ${10}^{-2}$
• Typically modeled as depolarizing or coherent rotation errors

2. Measurement Errors: Readout (SPAM — State Preparation And Measurement) errors:

• Assignment error rate: $\sim 1\mathrm{\%}$ to $5\mathrm{\%}$
• $P(\text{read }0|\text{state }1)$ and $P(\text{read }1|\text{state }0)$ can be asymmetric
• Modeled as a classical confusion matrix

3. Decoherence: Qubits lose quantum information over time:

• $T_1$ (relaxation time): Energy decay, typically $20\mu s$ to $200\mu s$
• $T_2$ (dephasing time): Phase coherence loss, typically $10\mu s$ to $150\mu s$
• Gate times: $\sim 20ns$ to $200ns$

4. Cross-Talk: Unwanted coupling between qubits during operations:

• Spectral cross-talk: Simultaneous gate operations interfere
• Always-on coupling: Residual interaction between neighboring qubits

5. Leakage: Qubit state escapes the computational subspace:

• Population in $|2⟩$ or higher energy levels
• Particularly problematic for superconducting transmon qubits

Modeling Noise with pyqpanda3

pyqpanda3's NoiseModel class supports configuring noise for realistic simulations:

from pyqpanda3.core import CPUQVM, NoiseModel, QProg, QGate
from pyqpanda3.core import H, CNOT, measure, depolarizing_error, GateType

# Create a noise model
noise = NoiseModel()

# Add depolarizing noise to all single-qubit gates
error_1q = depolarizing_error(0.001)
noise.add_all_qubit_quantum_error(error_1q, GateType.H)

# Add depolarizing noise to all two-qubit gates
error_2q = depolarizing_error(0.01)
noise.add_all_qubit_quantum_error(error_2q, GateType.CNOT)

# Run noisy simulation
qvm = CPUQVM()
prog = QProg()
prog << H(0) << CNOT(0, 1) << measure([0, 1], [0, 1])
qvm.run(prog, shots=1000, model=noise)
result = qvm.result()

Noise-Aware Circuit Design

Principles for designing circuits that are robust to noise:

1. Minimize two-qubit gates: They have the highest error rates
2. Minimize circuit depth: Errors accumulate with each time step
3. Use noise-aware transpilation: Map circuits to qubits with best connectivity and coherence
4. Exploit symmetries: Design circuits where noise cancels (e.g., dynamical decoupling)

Error Mitigation Techniques

Error mitigation reduces the impact of noise without full error correction:

Zero-Noise Extrapolation (ZNE):

• Run the circuit at multiple noise levels (by folding gates to amplify noise)
• Extrapolate results to the zero-noise limit
• Typically uses linear or exponential fitting

Probabilistic Error Cancellation (PEC):

• Characterize the noise channel $\mathcal{E}$
• Apply the inverse channel ${\mathcal{E}}^{-1}$ probabilistically
• Produces unbiased estimates at the cost of increased sampling

Measurement Error Mitigation:

• Characterize the readout error matrix $M$
• Apply $M^{-1}$ to the observed probability distribution
• Requires calibration runs for each measurement basis

Twirled Readout Error Extinction (TREX):

• Randomly flip qubits before measurement (twirling)
• Converts correlated readout errors into simpler diagonal form
• Easier to invert

---

Mathematical Summary

Key Relationships

$$\boxed{{\displaystyle \text{CPTP Map}}}⟷\boxed{{\displaystyle \text{Kraus Ops}}}⟷\boxed{{\displaystyle \text{Choi Matrix}}}⟷\boxed{{\displaystyle \text{SuperOp}}}⟷\boxed{{\displaystyle \text{PTM}}}$$

Bloch Sphere Picture

For single-qubit channels, the CPTP map acts on the Bloch vector $\overrightarrow{r}$ as an affine transformation:

$${\overrightarrow{r}}^{\prime }=M\overrightarrow{r}+\overrightarrow{t}$$

where $M$ is a $3\times 3$ real matrix and $\overrightarrow{t}$ is a translation vector.

Channel Type	$M$	$\overrightarrow{t}$
Depolarizing ($p$)	$(1-p)I$	$\overrightarrow{0}$
Bit Flip ($p$)	$\text{diag}(1,1-2p,1-2p)$	$\overrightarrow{0}$
Amplitude Damping ($\gamma$)	$\left(\begin{array}{ccc}\sqrt{1-\gamma }& 0& 0\\ 0& \sqrt{1-\gamma }& 0\\ 0& 0& 1-\gamma \end{array}\right)$	$(0,0,\gamma )$
Phase Damping ($\lambda$)	$\text{diag}(\sqrt{1-\lambda },\sqrt{1-\lambda },1)$	$\overrightarrow{0}$

Unital channels ($\overrightarrow{t}=\overrightarrow{0}$) preserve the maximally mixed state and only shrink/rotate the Bloch sphere. Non-unital channels ($\overrightarrow{t}\ne \overrightarrow{0}$) also translate the Bloch sphere, driving it toward a preferred state.

---

See Also

• NoiseModel API — API reference for noise configuration
• Quantum Channel Representations — Kraus, Chi, Choi, SuperOp, PTM classes
• DensityMatrix API — Density matrix operations
• Quantum Information Theory — State representations, fidelity, and distance measures
• Simulation Workflow Diagram — Visual noise simulation pipeline