noise/index.py

class Error

A Kraus/error operator represented as a NumPy ndarray subclass.

Conceptually, an error operator $E$ acts on a state as $\rho \mapsto E\rho E^{†}$, and a noise channel is typically a collection $\{E_k\}$.

name	type	default
correctable	bool	False
d	int	None
name	str	None
params	dict[str, Any]	None

class Channel

A quantum channel represented in Kraus form.

For Kraus operators $\{E_k\}$, the channel acts as $\mathrm{\Phi }(\rho )=\sum _k{E}_k\rho E_k^{†}$.

name	type	default
correctables	list[Union[int, list[int]]]	None
d	int	None
ops	list[Error]	None

init

No Definition provided

def __init__(self: Any, ops: list[Error]) -> Any

Implementation

def __init__(self, ops: list[Error]):
    assert isinstance(ops, list) and len(ops) > 0, 'ops must be List[ops]'
    self.ops = unnull(ops)
    self.d = ops[0].d if isinstance(ops[0], Error) else int(ops[0].shape[0])
    self.correctables = []

run

Apply the channel in Kraus form: $\rho \mapsto \sum _k{E}_k\rho E_k^{†}$.

def run(self: Any, rho: Union[State, np.ndarray]) -> np.ndarray

Implementation

def run(self, rho: Union[State, np.ndarray]) -> np.ndarray:
    rho_arr: Any = getattr(rho, 'tensor', rho)
    result = [O @ rho_arr @ O.conj().T for O in self.ops]
    return np.sum(result, axis=0)

correctable

Return the subset(s) of Kraus operators marked as correctable (if any).

def correctable(self: Any) -> Any

Implementation

def correctable(self) -> Any:
    if not self.correctables:
        return []
    c0 = self.correctables[0]
    if isinstance(c0, int):
        idxs = [i for i in self.correctables if isinstance(i, int)]
        return [self.ops[i] for i in idxs]
    if isinstance(c0, list):
        Ek: list[list[Error]] = []
        sets = [s for s in self.correctables if isinstance(s, list)]
        for s in sets:
            Ek.append([self.ops[i] for i in s])
        return Ek
    return Exception("Please don't change correctables")

isTP

Check trace-preservation (TP) via $\sum _k{E}_k^{†}{E}_k=I$ (approx.).

def isTP(self: Any) -> bool

Implementation

def isTP(self) -> bool:
    ti = [np.trace(O.conj().T @ O) for O in self.ops]
    return bool(np.isclose(sum(ti), 1.0))

isCP

Check complete-positivity (CP) by verifying Choi matrix is PSD.

def isCP(self: Any) -> bool

Implementation

def isCP(self) -> bool:
    J = self.toChoi()
    eig = np.linalg.eigvalsh(J)
    return bool(np.all(eig >= -1e-08))

isCPTP

Check if the channel is CPTP (completely positive and trace preserving).

def isCPTP(self: Any) -> bool

Implementation

def isCPTP(self) -> bool:
    return self.isCP and self.isTP

toChoi

Compute the Choi matrix $J(\mathrm{\Phi })=\sum _{i,j}|i⟩⟨j|\otimes \mathrm{\Phi }(|i⟩⟨j|)$.

def toChoi(self: Any) -> np.ndarray

Implementation

def toChoi(self) -> np.ndarray:
    d = self.d
    J = np.zeros((d * d, d * d), dtype=complex)
    basis = np.eye(d, dtype=complex)
    for i in range(d):
        for j in range(d):
            Eij = np.outer(basis[:, i], basis[:, j].conj())
            PhiE = self.run(Eij)
            J += np.kron(Eij, PhiE)
    return J

toSuperop

Compute the superoperator $S$ such that $\mathrm{vec}(\mathrm{\Phi }(\rho ))=S\mathrm{vec}(\rho )$.

def toSuperop(self: Any) -> np.ndarray

Implementation

def toSuperop(self) -> np.ndarray:
    d = self.d
    S = np.zeros((d * d, d * d), dtype=complex)
    I = np.eye(d, dtype=complex)
    for k in range(d * d):
        ek = I.flatten()[k]
        E = ek.reshape(d, d)
        vecPhi = self.run(E).flatten()
        S[:, k] = vecPhi
    return S

toStinespring

Compute a Stinespring isometry $V$ by stacking Kraus operators.

Constructs $V:{\mathbb{C}}^d\to {\mathbb{C}}^d\otimes {\mathbb{C}}^r$ with $V=\sum _k|k⟩\otimes E_k$, represented as a $(dr)\times d$ matrix.

def toStinespring(self: Any) -> np.ndarray

Implementation

def toStinespring(self) -> np.ndarray:
    K = len(self.ops)
    d = self.d
    r = K
    V = np.zeros((d * r, d), dtype=complex)
    for n, O in enumerate(self.ops):
        V[n * d:(n + 1) * d, :] = O
    return V

Ak

Alias for the Kraus list $\{E_k\}$

def Ak(self: Any) -> list[Error]

Implementation

def Ak(self) -> list[Error]:
    return self.ops

unnull

Filter out (approximately) zero operators.

Drops any matrix $A$ with $\parallel A\parallel \approx 0$ (elementwise up to tolerance), useful to clean Kraus lists.

def unnull(lst: List[np.ndarray]) -> List[np.ndarray]

Implementation

def unnull(lst: List[np.ndarray]) -> List[np.ndarray]:
    return [matrix for matrix in lst if not np.all(np.isclose(matrix, 0, atol=1e-08))]