qudit

Appearance

noise/model.py ​

class PhysicalNoise ​

Noise model derived from physical T1/T2 parameters via Lindblad integration.

init ​

No Definition provided

py
def __init__(self: Any, T1: Any, T2: Any, method: Any, gate_times: Any, seed: Any) -> Any
Implementation
python
def __init__(self, T1, T2, method='free', gate_times=None, seed=None):
    self.T1 = T1
    self.T2 = T2
    self.method = method
    self.gate_times = gate_times or {}
    self.generator = pt.Generator().manual_seed(seed) if seed is not None else None
    self._cache = {}

params_for ​

No Definition provided

py
def params_for(self: Any, wire: int) -> tuple[float, float]
Implementation
python
def params_for(self, wire: int) -> tuple[float, float]:
    T1 = self.T1[wire] if isinstance(self.T1, list) else self.T1
    T2 = self.T2[wire] if isinstance(self.T2, list) else self.T2
    return (T1, T2)

kraus_for ​

No Definition provided

py
def kraus_for(self: Any, gate_name: str, wire: int, d: int) -> pt.Tensor
Implementation
python
def kraus_for(self, gate_name: str, wire: int, d: int) -> pt.Tensor:
    key = (gate_name, wire, d)
    if key in self._cache:
        return self._cache[key]
    T1, T2 = self.params_for(wire)
    t = self._gate_time(gate_name)
    result = lindblad_kraus(None, T1, T2, t, d)
    self._cache[key] = result
    return result

class WeylNoise ​

Depolarising-style noise via Weyl (generalized Pauli) operators.

init ​

No Definition provided

py
def __init__(self: Any, p: float, seed: Any) -> Any
Implementation
python
def __init__(self, p: float, seed=None):
    self.p = p
    self.generator = pt.Generator().manual_seed(seed) if seed is not None else None
    self._cache: dict[int, pt.Tensor] = {}

kraus_for ​

No Definition provided

py
def kraus_for(self: Any, gate_name: str, wire: int, d: int) -> pt.Tensor
Implementation
python
def kraus_for(self, gate_name: str, wire: int, d: int) -> pt.Tensor:
    if d not in self._cache:
        self._cache[d] = self._build(d)
    return self._cache[d]

class CoherentNoise ​

Coherent (unitary) error model: perturbs a gate by a random GUE rotation.

init ​

No Definition provided

py
def __init__(self: Any, eps: float) -> Any
Implementation
python
def __init__(self, eps: float):
    self.eps = eps

perturb ​

No Definition provided

py
def perturb(self: Any, U: pt.Tensor, d: int) -> pt.Tensor
Implementation
python
def perturb(self, U: pt.Tensor, d: int) -> pt.Tensor:
    A = pt.randn(d, d, dtype=C128)
    G = (A + A.conj().T) / 2.0
    noise = pt.linalg.matrix_exp(-1j * self.eps * G)
    return (noise @ U.to(C128)).to(U.dtype)