qkd.gmcs
Gaussian-modulated coherent state preparation and encoding.
class GMCSTransmitter
class GMCSTransmitter:
def __init__(self, variance: float = 4.0, seed: int = None):
"""
Initialize GMCS transmitter (Alice).
Parameters:
variance: Modulation variance V_A in SNU (default: 4.0)
seed: Random seed for reproducibility
"""
def prepare_states(self, n_symbols: int) -> np.ndarray:
"""Generate n_symbols coherent states."""
def get_modulation_data(self) -> Tuple[np.ndarray, np.ndarray]:
"""Return (x_quadratures, p_quadratures) arrays."""
Example:
# Create transmitter with V_A = 4 SNU tx = GMCSTransmitter(variance=4.0, seed=42) states = tx.prepare_states(n_symbols=10000) x_data, p_data = tx.get_modulation_data()
class GMCSReceiver
class GMCSReceiver:
def __init__(self, detection_mode: str = "homodyne",
quantum_efficiency: float = 0.6,
electronic_noise: float = 0.01):
"""
Initialize GMCS receiver (Bob).
Parameters:
detection_mode: "homodyne" or "heterodyne"
quantum_efficiency: Detector QE (0-1)
electronic_noise: Electronic noise in SNU
"""
def measure(self, states: np.ndarray,
channel: QuantumChannel) -> np.ndarray:
"""Perform coherent detection on received states."""
qkd.secret_key
Secret key rate calculations and security analysis.
class KeyRateCalculator
class KeyRateCalculator:
def __init__(self, reconciliation_efficiency: float = 0.95):
"""
Initialize key rate calculator.
Parameters:
reconciliation_efficiency: β parameter (0.8-0.98)
"""
def asymptotic_rate(self, params: ChannelParams) -> float:
"""Calculate asymptotic key rate (bits/symbol)."""
def finite_size_rate(self, params: ChannelParams,
block_size: int,
epsilon_sec: float = 1e-10) -> float:
"""Calculate finite-size key rate."""
def mutual_information(self, params: ChannelParams) -> float:
"""Calculate I_AB (Alice-Bob mutual information)."""
def holevo_bound(self, params: ChannelParams) -> float:
"""Calculate χ_BE (Eve's Holevo information)."""
Example:
calc = KeyRateCalculator(reconciliation_efficiency=0.95)
params = ChannelParams(
distance_km=25,
excess_noise=0.01,
variance=4.0,
detector_qe=0.6
)
key_rate = calc.asymptotic_rate(params)
print(f"Key rate: {key_rate:.4f} bits/symbol")
dataclass ChannelParams
@dataclass
class ChannelParams:
distance_km: float # Fiber distance
excess_noise: float # ξ in SNU
variance: float # V_A in SNU
detector_qe: float # η_det
fiber_loss_db_km: float = 0.2
pic_loss_db: float = 6.0
electronic_noise: float = 0.01
qkd.detectors
Detector modeling and characterization.
class BalancedDetector
class BalancedDetector:
def __init__(self,
quantum_efficiency: float = 0.6,
bandwidth_ghz: float = 20,
electronic_noise_snu: float = 0.01,
cmrr_db: float = 30):
"""
Model balanced (differential) detector.
Parameters:
quantum_efficiency: η_det (0-1)
bandwidth_ghz: 3dB electrical bandwidth
electronic_noise_snu: v_el in SNU
cmrr_db: Common-mode rejection ratio
"""
def shot_noise_clearance(self, lo_power_mw: float) -> float:
"""Calculate SNR above electronic noise floor (dB)."""
def effective_efficiency(self) -> float:
"""Return effective QE including all losses."""
qkd.pic_budget
Photonic integrated circuit loss budget analysis.
class PICLossBudget
class PICLossBudget:
def __init__(self):
"""Initialize PIC loss budget tracker."""
def add_component(self, name: str, loss_db: float):
"""Add component to loss budget."""
def total_loss(self) -> float:
"""Return total PIC loss in dB."""
def transmittance(self) -> float:
"""Return linear transmittance (0-1)."""
def summary(self) -> pd.DataFrame:
"""Return DataFrame with loss breakdown."""
Example:
budget = PICLossBudget()
budget.add_component("Input coupler", 3.5)
budget.add_component("Waveguide (2cm)", 1.0)
budget.add_component("Modulator", 2.0)
budget.add_component("Output coupler", 3.5)
print(f"Total PIC loss: {budget.total_loss():.1f} dB")
print(f"Transmittance: {budget.transmittance():.3f}")
common.gaussian
Gaussian state utilities and shot noise conventions.
Functions
def g(x: float) -> float:
"""
Von Neumann entropy function.
g(x) = (x+1)*log2(x+1) - x*log2(x)
"""
def covariance_matrix(variance: float,
transmittance: float,
excess_noise: float) -> np.ndarray:
"""
Construct 4x4 covariance matrix for Alice-Bob state.
"""
def symplectic_eigenvalues(gamma: np.ndarray) -> np.ndarray:
"""
Calculate symplectic eigenvalues of covariance matrix.
"""
def to_snu(variance_linear: float) -> float:
"""Convert linear variance to shot noise units."""
def from_snu(variance_snu: float) -> float:
"""Convert shot noise units to linear variance."""
common.noise
Channel and detector noise modeling.
class NoiseModel
class NoiseModel:
def __init__(self,
excess_noise: float = 0.01,
electronic_noise: float = 0.01):
"""
Initialize noise model.
All values in Shot Noise Units (SNU).
"""
def channel_added_noise(self, transmittance: float) -> float:
"""Calculate χ_line = (1-T)/T."""
def total_noise(self, transmittance: float,
detector_qe: float) -> float:
"""Calculate total referred noise χ_tot."""
def noise_breakdown(self, transmittance: float) -> dict:
"""Return dict with individual noise contributions."""
Command Line Interface
# Basic simulation python -m qkd.cli simulate --distance 25 --variance 4 # Sweep distance python -m qkd.cli sweep --param distance --start 1 --end 100 # Export results python -m qkd.cli simulate --distance 25 --output results.csv # Full options python -m qkd.cli --help
CLI Arguments:
| --distance | Fiber distance in km |
| --variance | Modulation variance V_A (SNU) |
| --excess-noise | Excess noise ξ (SNU) |
| --beta | Reconciliation efficiency |
| --detector-qe | Detector quantum efficiency |
| --output | Output file path (CSV) |