Quantum Positive Maps

---
name: quantum-positive-maps
description: "Analysis of positive trace-preserving (PTP) maps in quantum information theory. Petz recovery map construction, sufficiency conditions, and Jordan algebra generalizations. Use when: (1) Analyzing quantum state interconversion via positive maps, (2) Implementing Petz recovery for quantum channel inversion, (3) Studying minimal sufficient algebras in quantum systems, (4) Generalizing Koashi-Imoto decomposition to PTP setting."
---

# Quantum Positive Maps

Analysis of positive trace-preserving (PTP) maps in quantum information theory.

## Positive Trace-Preserving (PTP) Maps

### Definition

A map Φ: B(H) → B(H') is:
- **Positive**: Φ(A) ≥ 0 whenever A ≥ 0
- **Trace-preserving**: Tr[Φ(A)] = Tr[A]
- **NOT necessarily completely positive**

### Importance

PTP maps describe:
- Physical processes beyond quantum channels
- Partial measurements
- Non-CP operations (e.g., transpose)

## Petz Recovery Map

### Standard Petz Recovery

For completely positive trace-preserving (CPTP) map Φ and state σ:

```
R_σ^Φ(A) = σ Φ†(Φ(σ)^{-1/2} A Φ(σ)^{-1/2})
```

Properties:
- **Approximate inversion**: R_σ^Φ∘Φ ≈ Id when Φ is sufficient for σ
- **Monotonicity**: Petz recovery saturates data processing inequality

### Generalization to PTP

For PTP map Φ, Petz recovery construction extends:
```
R_σ^Φ(A) = σ Φ†(J(Φ(σ))^{-1/2} A J(Φ(σ))^{-1/2})
```

Where J is Jordan product operation.

## Sufficiency and Minimal Algebras

### Sufficiency Definition

A map Φ is **sufficient** for family of states {σ_i} if:
```
Φ(σ_i) distinct for each i
```

And information about which σ_i is present can be recovered from Φ(σ_i).

### Koashi-Imoto Decomposition

For CPTP maps, minimal sufficient *-algebra decomposition:
```
H = ⊕_α H_α ⊗ K_α
```

Φ acts trivially on K_α subspaces.

### Generalization to PTP

Minimal sufficient **Jordan algebra** decomposition:
```
H = ⊕_α J_α
```

Where J_α are Jordan subalgebras (not necessarily *-subalgebras).

## Neyman-Pearson Tests

### Statistical Tests and Jordan Algebras

Key result: **Neyman-Pearson tests generate minimal sufficient Jordan algebra**

Connection:
1. Hypothesis testing → optimal discrimination
2. Neyman-Pearson lemma → optimal test structure
3. Optimal tests → Jordan algebra elements

### Implications

- Statistical tests determine algebraic structure
- Minimal sufficient algebra has statistical interpretation
- Quantum hypothesis testing connects to algebraic decomposition

## Mathematical Framework

### Jordan Algebras

Jordan product:
```
A ◦ B = (AB + BA)/2
```

Jordan algebra: closed under ◦ product (not necessarily associative).

### Minimal Sufficient Jordan Algebra

For PTP map Φ and family {σ_i}:
```
J_min = {A : Φ(A) = Φ(A ◦ σ_i) for some i}
```

Generated by Neyman-Pearson test operators.

### Recovery Map Construction

```python
def construct_petz_recovery_ptp(Phi, sigma):
    """
    Construct Petz recovery for PTP map.
    
    Steps:
    1. Compute Phi(sigma)
    2. Find Jordan inverse
    3. Apply recovery formula
    """
    
    # Output state
    sigma_out = Phi(sigma)
    
    # Jordan inverse (generalized)
    J_inv = jordan_inverse(sigma_out)
    
    # Recovery map
    def recovery(A):
        # Apply Phi† (dual map)
        temp = Phi.dual(J_inv.sqrt() @ A @ J_inv.sqrt())
        # Jordan product with sigma
        return sigma @ temp
    
    return recovery
```

## Implementation Patterns

### Pattern 1: Sufficiency Test

```python
def test_sufficiency(Phi, states):
    """
    Test if PTP map Φ is sufficient for state family.
    
    Check:
    1. Output states distinct
    2. Information recoverable
    3. Minimal algebra condition
    """
    
    # Apply map to all states
    outputs = [Phi(sigma) for sigma in states]
    
    # Check distinctness
    for i, j in combinations(outputs, 2):
        if np.allclose(outputs[i], outputs[j]):
            return f"Not sufficient: σ_{i} and σ_{j} indistinguishable"
    
    # Construct minimal Jordan algebra
    J_min = construct_minimal_jordan_algebra(Phi, states)
    
    return f"Sufficient, minimal algebra dimension: {J_min.dim}"
```

### Pattern 2: Koashi-Imoto Generalization

```python
def decompose_ptp_map(Phi, sigma):
    """
    Decompose PTP map similar to Koashi-Imoto.
    
    Find Jordan subalgebras where Φ acts trivially.
    """
    
    # Find minimal sufficient Jordan algebra
    J_min = find_minimal_jordan_algebra(Phi, sigma)
    
    # Decompose Hilbert space
    decomposition = jordan_decompose(J_min)
    
    return decomposition
```

## Applications

1. **Quantum Channel Inversion**: Petz recovery for approximate channel reversal
2. **Quantum Error Correction**: Sufficiency for error-correcting codes
3. **Quantum Hypothesis Testing**: Neyman-Pearson connection
4. **Resource Theory**: Monotonicity and recovery

## References

See [jordan_algebras.md](references/jordan_algebras.md) for Jordan algebra theory.

## Source

Based on arxiv:2604.08380 - "Sufficiency and Petz recovery for positive maps" by Lauritz van Luijk & Henrik Wilming.