Skip to content

sk_vec_norm

Compute the S(k)-norm of a vector.

sk_vector_norm 

sk_vector_norm(rho: ndarray, k: int = 1, dim: int | list[int] | None = None) -> float | floating

Compute the S(k)-norm of a vector 1.

The \(S(k)\)-norm of of a vector \(|v \rangle\) is defined as:

\[ \big|\big| |v\rangle \big|\big|_{s(k)} := \text{sup}_{|w\rangle} \Big\{ |\langle w | v \rangle| : \text{Schmidt-rank}(|w\rangle) \leq k \Big\} \]

It's also equal to the Euclidean norm of the vector of \(|v\rangle\)'s k largest Schmidt coefficients.

This function was adapted from QETLAB.

Examples:

The smallest possible value of the \(S(k)\)-norm of a pure state is \(\sqrt{\frac{k}{n}}\), and is attained exactly by the "maximally entangled states".

from toqito.states import max_entangled
from toqito.state_props import sk_vector_norm
import numpy as np
# Maximally entagled state.
v = max_entangled(4)
print(sk_vector_norm(v))

0.5

Parameters:

  • rho (ndarray) –

    A vector.

  • k (int, default: 1 ) –

    An int.

  • dim (int | list[int] | None, default: None ) –

    The dimension of the two sub-systems. By default it's assumed to be equal.

Returns:

  • float | floating –

    The S(k)-norm of rho.

References

1 Johnston, Nathaniel and Kribs, David. A family of norms with applications in quantum information theory. Journal of Mathematical Physics. vol. 51(8). (2010). doi:10.1063/1.3459068.

Source code in toqito/state_props/sk_vec_norm.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
def sk_vector_norm(rho: np.ndarray, k: int = 1, dim: int | list[int] | None = None) -> float | np.floating:
    r"""Compute the S(k)-norm of a vector [@Johnston_2010_AFamily].

    The \(S(k)\)-norm of of a vector \(|v \rangle\) is
    defined as:

    \[
        \big|\big| |v\rangle \big|\big|_{s(k)} := \text{sup}_{|w\rangle} \Big\{
            |\langle w | v \rangle| : \text{Schmidt-rank}(|w\rangle) \leq k
        \Big\}
    \]

    It's also equal to the Euclidean norm of the vector of \(|v\rangle\)'s
    k largest Schmidt coefficients.

    This function was adapted from QETLAB.

    Examples:
        The smallest possible value of the \(S(k)\)-norm of a pure state is
        \(\sqrt{\frac{k}{n}}\), and is attained exactly by the "maximally entangled
        states".

        ```python exec="1" source="above"
        from toqito.states import max_entangled
        from toqito.state_props import sk_vector_norm
        import numpy as np
        # Maximally entagled state.
        v = max_entangled(4)
        print(sk_vector_norm(v))
        ```

    Args:
        rho: A vector.
        k: An int.
        dim: The dimension of the two sub-systems. By default it's assumed to be equal.

    Returns:
        The S(k)-norm of `rho`.

    """
    dim_xy = rho.shape[0]

    # Set default dimension if none was provided.
    if dim is None:
        dim_val = int(np.round(np.sqrt(dim_xy)))
    elif isinstance(dim, int):
        dim_val = dim
    else:
        dim_val = None

    # Allow the user to enter in a single integer for dimension.
    if dim_val is not None:
        dim_arr = np.array([dim_val, dim_xy / dim_val])
        dim_arr[1] = int(np.round(dim_arr[1]))
    else:
        dim_arr = np.array(dim)

    # It's faster to just compute the norm of `rho` directly if that will give
    # the correct answer.
    if k >= min(dim_arr):
        nrm = np.linalg.norm(rho, 2)
    else:
        coef, _, _ = schmidt_decomposition(rho, dim_arr, k)
        nrm = np.linalg.norm(coef)

    return nrm