Skip to content

chessboard

Chessboard state represent the state of a chessboard used in quantum chess.

In a quantum chessboard, each chess piece is quantum having a superposition of channel states, giving rise to a unique chess piece.

chessboard 

chessboard(
    mat_params: list[float],
    s_param: float | None = None,
    t_param: float | None = None,
) -> ndarray

Produce a chessboard state 1.

Generates the chessboard state defined in 1. Note that, for certain choices of s_param and t_param, this state will not have positive partial transpose, and thus may not be bound entangled.

Parameters:

  • mat_params (list[float]) –

    Parameters of the chessboard state as defined in 1.

  • s_param (float | None, default: None ) –

    Default is np.conj(mat_params[2]) / np.conj(mat_params[5]).

  • t_param (float | None, default: None ) –

    Default is t_param = mat_params[0] * mat_params[3] / mat_params[4].

Returns:

  • ndarray –

    A chessboard state.

Examples:

The standard chessboard state can be invoked using |toqito⟩ as

from toqito.states import chessboard
print(chessboard([1, 2, 3, 4, 5, 6], 7, 8))

[[ 0.22592593  0.          0.12962963  0.          0.          0.          0.17777778  0.          0.        ]
 [ 0.          0.01851852  0.          0.          0.          0.01111111  0.          0.02962963  0.        ]
 [ 0.12962963  0.          0.18148148  0.          0.15555556  0.          0.          0.          0.        ]
 [ 0.          0.          0.          0.01851852  0.          0.02222222  0.         -0.01481481  0.        ]
 [ 0.          0.          0.15555556  0.          0.22592593  0.         -0.14814815  0.          0.        ]
 [ 0.          0.01111111  0.          0.02222222  0.          0.03333333  0.          0.          0.        ]
 [ 0.17777778  0.          0.          0.         -0.14814815  0.          0.23703704  0.          0.        ]
 [ 0.          0.02962963  0.         -0.01481481  0.          0.          0.          0.05925926  0.        ]
 [ 0.          0.          0.          0.          0.          0.          0.          0.          0.        ]]

References

1 Bru\ss{}, Dagmar and Peres, Asher. Construction of quantum states with bound entanglement. Phys. Rev. A. vol. 61. (2000). doi:10.1103/PhysRevA.61.030301.

Source code in toqito/states/chessboard.py 
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
def chessboard(mat_params: list[float], s_param: float | None = None, t_param: float | None = None) -> np.ndarray:
    r"""Produce a chessboard state [@bruss2000construction].

    Generates the chessboard state defined in [@bruss2000construction]. Note that, for certain choices of
    `s_param` and `t_param`, this state will not have positive partial transpose, and
    thus may not be bound entangled.

    Args:
        mat_params: Parameters of the chessboard state as defined in [@bruss2000construction].
        s_param: Default is `np.conj(mat_params[2]) / np.conj(mat_params[5])`.
        t_param: Default is `t_param = mat_params[0] * mat_params[3] / mat_params[4]`.

    Returns:
        A chessboard state.

    Examples:
        The standard chessboard state can be invoked using `|toqito⟩` as

        ```python exec="1" source="above" result="text"
        from toqito.states import chessboard
        print(chessboard([1, 2, 3, 4, 5, 6], 7, 8))
        ```

    """
    if s_param is None:
        s_param = np.conj(mat_params[2]) / np.conj(mat_params[5])
    if t_param is None:
        t_param = mat_params[0] * mat_params[3] / mat_params[4]

    v_1 = np.array([[mat_params[4], 0, s_param, 0, mat_params[5], 0, 0, 0, 0]])
    v_2 = np.array([[0, mat_params[0], 0, mat_params[1], 0, mat_params[2], 0, 0, 0]])
    v_3 = np.array([[np.conj(mat_params[5]), 0, 0, 0, -np.conj(mat_params[4]), 0, t_param, 0, 0]])
    v_4 = np.array([[0, np.conj(mat_params[1]), 0, -np.conj(mat_params[0]), 0, 0, 0, mat_params[3], 0]])
    rho = v_1.conj().T @ v_1 + v_2.conj().T @ v_2 + v_3.conj().T @ v_3 + v_4.conj().T @ v_4
    return rho / np.trace(rho)