Skip to content

pretty_good_measurement

Compute the set of pretty good measurements from an ensemble.

pretty_good_measurement 

pretty_good_measurement(states: list[ndarray], probs: list[float] | None = None, tol: float = 1e-08) -> list[ndarray]

Return the set of pretty good measurements from a set of vectors and corresponding probabilities.

This computes the "pretty good measurement" (PGM), also known as the square-root measurement, which is a widely used measurement for quantum state discrimination [@Belavkin_1975_Optimal,Hughston_1993_Complete].

The PGM is the set of POVMs \((G_1, \ldots, G_n)\) such that

\[ G_i = P^{-1/2} \left(p_i \rho_i\right) P^{-1/2} \quad \text{where} \quad P = \sum_{i=1}^n p_i \rho_i. \]

See

pretty_bad_measurement()

Examples:

Consider the collection of trine states.

\[ u_0 = |0\rangle, \quad u_1 = -\frac{1}{2}\left(|0\rangle + \sqrt{3}|1\rangle\right), \quad \text{and} \quad u_2 = -\frac{1}{2}\left(|0\rangle - \sqrt{3}|1\rangle\right). \]
from toqito.states import trine
from toqito.measurements import pretty_good_measurement

states = trine()
probs = [1 / 3, 1 / 3, 1 / 3]
pgm = pretty_good_measurement(states, probs)
print(pgm)

[array([[0.66666667, 0. ], [0. , 0. ]]), array([[0.16666667, 0.28867513], [0.28867513, 0.5 ]]), array([[ 0.16666667, -0.28867513], [-0.28867513, 0.5 ]])]

Raises:

  • ValueError –

    If number of vectors does not match number of probabilities.

  • ValueError –

    If probabilities do not sum to 1.

Parameters:

  • states (list[ndarray]) –

    A collection of states provided as either vectors or density matrices.

  • probs (list[float] | None, default: None ) –

    A set of fixed probabilities for each quantum state. If not provided, a uniform distribution is assumed.

  • tol (float, default: 1e-08 ) –

    A tolerance value for numerical comparisons.

Returns:

  • list[ndarray] –

    A list of POVM operators for the PGM.

Source code in toqito/measurements/pretty_good_measurement.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def pretty_good_measurement(
    states: list[np.ndarray], probs: list[float] | None = None, tol: float = 1e-8
) -> list[np.ndarray]:
    r"""Return the set of pretty good measurements from a set of vectors and corresponding probabilities.

    This computes the "pretty good measurement" (PGM), also known as the
    square-root measurement, which is a widely used measurement for quantum
    state discrimination [@Belavkin_1975_Optimal,Hughston_1993_Complete].

    The PGM is the set of POVMs \((G_1, \ldots, G_n)\) such that

    \[
        G_i = P^{-1/2} \left(p_i \rho_i\right) P^{-1/2} \quad \text{where} \quad
        P = \sum_{i=1}^n p_i \rho_i.
    \]

    !!! See Also
        [pretty_bad_measurement()][toqito.measurements.pretty_bad_measurement.pretty_bad_measurement]

    Examples:
        Consider the collection of trine states.

        \[
            u_0 = |0\rangle, \quad
            u_1 = -\frac{1}{2}\left(|0\rangle + \sqrt{3}|1\rangle\right), \quad \text{and} \quad
            u_2 = -\frac{1}{2}\left(|0\rangle - \sqrt{3}|1\rangle\right).
        \]

        ```python exec="1" source="above"
        from toqito.states import trine
        from toqito.measurements import pretty_good_measurement

        states = trine()
        probs = [1 / 3, 1 / 3, 1 / 3]
        pgm = pretty_good_measurement(states, probs)
        print(pgm)
        ```

    Raises:
        ValueError: If number of vectors does not match number of probabilities.
        ValueError: If probabilities do not sum to 1.

    Args:
        states: A collection of states provided as either vectors or density matrices.
        probs: A set of fixed probabilities for each quantum state. If not provided, a uniform distribution is assumed.
        tol: A tolerance value for numerical comparisons.

    Returns:
        A list of POVM operators for the PGM.

    """
    n = len(states)

    # If not probabilities are explicitly given, assume a uniform distribution.
    if probs is None:
        probs = n * [1 / n]

    if len(states) != len(probs):
        raise ValueError(f"Number of states {len(states)} must be equal to number of probabilities {len(probs)}")

    if not np.isclose(sum(probs), 1):
        raise ValueError("Probability vector should sum to 1.")

    states = [to_density_matrix(state) for state in states]

    # 1. Assemble the average state.
    p_var = sum(probs[i] * states[i] for i in range(n))

    # 2. Diagonalize.
    vals, vecs = np.linalg.eigh(p_var)

    # 3. Invert only the non‑zero eigenvalues.
    inv_sqrt_vals = np.array([1 / np.sqrt(v) if v > tol else 0.0 for v in vals])

    # 4. Reconstruct P^{-1/2}.
    P_inv_sqrt = vecs @ np.diag(inv_sqrt_vals) @ vecs.conj().T

    # 5. Build PGM measurements.
    return [P_inv_sqrt @ (probs[i] * states[i]) @ P_inv_sqrt for i in range(n)]