Phase Reference Entanglement Control

---
name: phase-reference-entanglement-control
description: "Phase-reference control methodology for generating steady-state entanglement in open quantum systems using phase-sensitive reservoirs and local dissipation. Activation: steady-state entanglement, phase-sensitive reservoir, open quantum systems, Gaussian entanglement, local dissipation entanglement, covariance matrix quantum dynamics."
---

# Phase-Reference Control of Steady-State Entanglement in Open Quantum Systems

**Based on:** "Phase-Reference Control of Steady-State Entanglement in Open Quantum Systems" (arXiv: 2605.03978)

## Core Insight

Steady-state entanglement in open quantum systems is controlled by the **phase reference** of a phase-sensitive reservoir. Purely local, phase-sensitive dissipation can generate entanglement when combined with appropriate phase relationships between modes.

### Key Finding

Local dissipation alone (without direct interaction between modes) can generate steady-state entanglement if:
1. The reservoir is phase-sensitive (squeezed thermal bath)
2. The phase reference between modes is properly controlled
3. The dissipation rates are balanced appropriately

## Mathematical Framework

### Covariance Matrix Approach

For Gaussian-preserving dynamics, the state is fully characterized by the covariance matrix V:

```
dV/dt = A·V + V·A^T + D
```

Where:
- A: Drift matrix (determines system dynamics)
- D: Diffusion matrix (determined by reservoir properties)

Steady state: `A·V_ss + V_ss·A^T + D = 0`

### Entanglement Criterion (Logarithmic Negativity)

```
E_N = max(0, -log_2(ν̃_-))
```

Where ν̃_- is the smallest symplectic eigenvalue of the partially transposed covariance matrix.

## Implementation Guide

### 1. Gaussian State Dynamics Simulation

```python
import numpy as np
from scipy.linalg import solve_lyapunov

def gaussian_dynamics(n_modes, A, D, dt=0.01, t_final=10.0):
    """Simulate Gaussian state dynamics for open quantum systems.
    
    Args:
        n_modes: Number of modes
        A: Drift matrix (2n × 2n)
        D: Diffusion matrix (2n × 2n)
        dt: Time step
        t_final: Final time
    
    Returns:
        V_ss: Steady-state covariance matrix
    """
    # Solve Lyapunov equation for steady state
    V_ss = solve_lyapunov(A, -D)
    
    return V_ss

def partial_transpose_covariance(V, n_modes, mode_to_transpose=1):
    """Apply partial transpose to covariance matrix.
    
    For mode i: p_i → -p_i in the covariance matrix.
    """
    V_pt = V.copy()
    idx_p = 2 * mode_to_transpose + 1
    
    V_pt[:, idx_p] *= -1
    V_pt[idx_p, :] *= -1
    
    return V_pt
```

### 2. Entanglement Verification

```python
def symplectic_eigenvalues(V):
    """Compute symplectic eigenvalues of covariance matrix.
    
    Uses Williamson's theorem: V = S·D·S^T where D = diag(ν_1, ν_1, ..., ν_n, ν_n)
    """
    n = V.shape[0] // 2
    Omega = np.zeros((2*n, 2*n))
    for i in range(n):
        Omega[2*i, 2*i+1] = 1
        Omega[2*i+1, 2*i] = -1
    
    # Compute eigenvalues of |i·Omega·V|
    M = 1j * Omega @ V
    eigvals = np.abs(np.linalg.eigvals(M))
    
    # Symplectic eigenvalues come in pairs
    symplectic_eigs = np.sort(eigvals[:n])
    
    return symplectic_eigs

def logarithmic_negativity(V, n_modes):
    """Compute logarithmic negativity for bipartite Gaussian state."""
    V_pt = partial_transpose_covariance(V, n_modes)
    nu_tilde = symplectic_eigenvalues(V_pt)
    
    # Smallest symplectic eigenvalue determines entanglement
    nu_min = np.min(nu_tilde)
    
    if nu_min < 0.5:
        E_N = -np.log2(2 * nu_min)
    else:
        E_N = 0.0
    
    return E_N
```

### 3. Phase-Sensitive Reservoir Engineering

```python
def phase_sensitive_reservoir(n_modes, squeezing_r=0.5, phase=0.0, temperature=0.1):
    """Construct diffusion matrix for phase-sensitive reservoir.
    
    Args:
        n_modes: Number of modes
        squeezing_r: Squeezing parameter
        phase: Phase reference
        temperature: Thermal occupation
    """
    n = 2 * n_modes
    D = np.zeros((n, n))
    
    for i in range(n_modes):
        # Thermal contribution
        n_th = 1 / (np.exp(1 / temperature) - 1) if temperature > 0 else 0
        
        # Squeezing contribution (phase-sensitive)
        cosh_2r = np.cosh(2 * squeezing_r)
        sinh_2r = np.sinh(2 * squeezing_r)
        
        D[2*i, 2*i] = (n_th + 0.5) * cosh_2r + (n_th + 0.5) * sinh_2r * np.cos(2*phase)
        D[2*i+1, 2*i+1] = (n_th + 0.5) * cosh_2r - (n_th + 0.5) * sinh_2r * np.cos(2*phase)
        D[2*i, 2*i+1] = (n_th + 0.5) * sinh_2r * np.sin(2*phase)
        D[2*i+1, 2*i] = D[2*i, 2*i+1]
    
    return D
```

### 4. Optimization for Maximum Entanglement

```python
from scipy.optimize import minimize

def optimize_entanglement(n_modes, dissipation_rate=1.0):
    """Find optimal phase reference for maximum steady-state entanglement."""
    
    def objective(params):
        phase, squeezing = params
        
        # Construct drift and diffusion matrices
        A = -dissipation_rate * np.eye(2 * n_modes)
        D = phase_sensitive_reservoir(n_modes, squeezing, phase)
        
        # Get steady state
        V_ss = gaussian_dynamics(n_modes, A, D)
        
        # Compute entanglement
        E_N = logarithmic_negativity(V_ss, n_modes)
        
        return -E_N  # Minimize negative entanglement
    
    # Optimize over phase and squeezing
    result = minimize(objective, x0=[0.0, 0.5], 
                     bounds=[(0, 2*np.pi), (0, 2.0)])
    
    optimal_phase, optimal_squeezing = result.x
    max_entanglement = -result.fun
    
    return optimal_phase, optimal_squeezing, max_entanglement
```

## Pitfalls & Lessons Learned

### Critical Issues

1. **Phase reference stability**: Phase drift destroys entanglement
2. **Thermal noise**: Even small temperatures can suppress entanglement
3. **Asymmetric dissipation**: Different rates for different modes can help or hurt
4. **Gaussian assumption**: Non-Gaussian states need different analysis
5. **Finite bandwidth**: Real reservoirs have frequency-dependent properties

### Best Practices

1. **Verify symplectic eigenvalues** > 0.5 for physicality
2. **Use logarithmic negativity** for Gaussian entanglement quantification
3. **Benchmark against known results** (two-mode squeezed vacuum)
4. **Consider experimental constraints** (maximum squeezing, phase stability)
5. **Account for detection inefficiency** in experimental validation

## Activation

- **Keywords**: steady-state entanglement, phase-sensitive reservoir, open quantum systems, Gaussian entanglement, local dissipation, covariance matrix quantum, logarithmic negativity, quantum reservoir engineering
- **When to use**: Designing entanglement generation protocols, open quantum system analysis, quantum reservoir engineering, continuous-variable quantum information

## Related Skills

- `unlocking-vacuum-entanglement` - Vacuum entanglement structure analysis
- `quantum-reservoir-computing` - Quantum reservoir computing
- `bosonic-gkp-parity-encoding` - Bosonic quantum error correction