bound-entangled 0.1.0__py3-none-any.whl

bound_entangled-0.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: bound-entangled
+Version: 0.1.0
+Summary: Families of bound entangled states for Quantum Information
+Author-email: AVlyx <anton@vancleem.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AVlyx/bound-entangled
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: toqito>=1.3.0
+Requires-Dist: numpy>=2.4.1
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Dynamic: license-file
+
+# bound-entangled
+
+Reference implementations of several families of **bound entangled states** from
+the quantum information literature, as plain NumPy density matrices.
+
+A bound entangled state is entangled yet has a positive partial transpose (PPT),
+so no pure entanglement can be distilled from it. This library collects
+constructions that are otherwise scattered across papers into a single, tested
+package, each factory returning the density matrix `rho` of the state.
+
+## Installation
+
+```bash
+pip install -e .
+# with the test dependencies:
+pip install -e ".[test]"
+```
+
+Requires Python ≥ 3.9. Depends on [`toqito`](https://toqito.readthedocs.io) and
+NumPy.
+
+## Usage
+
+Packages are organized by the bipartite Hilbert space the states live in
+(`c3_otimes_c3` = C³ ⊗ C³, `cm_otimes_cn` = C^m ⊗ C^n, etc.).
+
+```python
+from c3_otimes_c3 import chessboard_extremal_PPT, tiles_upb, pyramid_upb
+from cd_otimes_cd import yu_oh
+from c5_otimes_c5 import sn3_grid_state
+
+rho = chessboard_extremal_PPT()   # 9x9 PPT-entangled chessboard state
+rho = yu_oh(d=3, x=0.5, y=0.5)    # Yu-Oh nonlocal bound entangled state
+```
+
+## States
+
+### `c3_otimes_c3` — C³ ⊗ C³
+
+| Factory | State | Reference |
+|---|---|---|
+| `chessboard`, `chessboard_extremal_PPT` | Bruß–Peres chessboard states | [quant-ph/9911056](https://arxiv.org/abs/quant-ph/9911056) |
+| `cross_hatch` | 3×3 "cross-hatch" grid state (CCNR-detected) | [1705.09261](https://arxiv.org/abs/1705.09261) |
+| `steering_state` | Steerable bound entangled state (counterexample to the stronger Peres conjecture) | [1405.0262](https://arxiv.org/abs/1405.0262) |
+| `tiles_upb`, `pyramid_upb` | States from the Tiles / Pyramid unextendible product bases | [quant-ph/9808030](https://arxiv.org/abs/quant-ph/9808030) |
+| `parametrized_upb` | Six-parameter family of UPBs generalizing Tiles / Pyramid | [quant-ph/9908070](https://arxiv.org/abs/quant-ph/9908070) |
+| `horodecki` | 3x3 Horodecki bound entangled state | [quant-ph/9703004](https://arxiv.org/abs/quant-ph/9703004) |
+
+
+### `c4_otimes_c4` — C⁴ ⊗ C⁴
+
+| Factory | State | Reference |
+|---|---|---|
+| `pianni` | 4×4 Benatti–Floreanini–Piani state | [quant-ph/0411095](https://arxiv.org/abs/quant-ph/0411095) |
+
+### `c5_otimes_c5` — C⁵ ⊗ C⁵
+
+| Factory | State | Reference |
+|---|---|---|
+| `sn3_grid_state` | Smallest known Schmidt-number-3 PPT bound entangled state | [2402.12966](https://arxiv.org/abs/2402.12966) |
+
+### `cd_otimes_cd` — C^d ⊗ C^d
+
+| Factory | State | Reference |
+|---|---|---|
+| `yu_oh`, `is_valid_yu_oh_input` | Yu–Oh family of nonlocal bound entangled states | [1509.08991](https://arxiv.org/abs/1509.08991) |
+| `gen_tiles1` | GenTiles1 UPB generalizing Tiles to d⊗d, even d≥4 | [quant-ph/9908070](https://arxiv.org/abs/quant-ph/9908070) |
+
+### `cm_otimes_cn` — C^m ⊗ C^n (parametric constructions)
+
+| Factory | State | Reference |
+|---|---|---|
+| `grid_state` | Quantum grid states from graph edges | [1705.09261](https://arxiv.org/abs/1705.09261) |
+| `generalized_grid_state` | Grid states generalized to hyperedges | [2402.12966](https://arxiv.org/abs/2402.12966) |
+| `random_NPT`, `random_PPT`, `random_PPT_close_to_the_PPT_edge` | Random density matrices by PPT class (rejection sampling) | — |
+| `gen_tiles2` | GenTiles2 UPB generalizing Tiles to m⊗n, n>3, m≥3, n≥m | [quant-ph/9908070](https://arxiv.org/abs/quant-ph/9908070) |
+
+
+## Documentation
+
+Full API docs (built with [MkDocs](https://www.mkdocs.org/) +
+[mkdocstrings](https://mkdocstrings.github.io/)) are published to GitHub Pages
+on every push to `main`. To preview locally:
+
+```bash
+pip install -e ".[docs]"
+mkdocs serve
+```
+
+## License
+
+MIT

bound_entangled-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+bound_entangled-0.1.0.dist-info/licenses/LICENSE,sha256=3aSIAWubi-IapGuDdpfZdzLZRr17TkXoHjqP-BvHSRI,1075
+c3_otimes_c3/__init__.py,sha256=kWt_O5UZF8saDQhglGO1wBxZ7_2xXo4Kd01cBW8j71w,380
+c3_otimes_c3/chessboard.py,sha256=l3vS8NUk-eiTRdAiZOyJ_G4VUpYgxmsZ31x4A-tBLLw,1681
+c3_otimes_c3/cross_hatch.py,sha256=097zRRe6YcBBbPGJl_99xt0Ym32ZI4Cx0Q5FbEMt3No,595
+c3_otimes_c3/horodecki.py,sha256=pBa7ml534dOGk08IBCs66-dnqBluVb5eO1Ngyq0_czA,793
+c3_otimes_c3/steering.py,sha256=gCFpWS1zG3l5ANYemGwW9SqrdA8PkW4dQKAcHdv3IYs,1588
+c3_otimes_c3/upb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+c3_otimes_c3/upb/parametrized_UPB.py,sha256=rs1BoTITomDv-X4sOvH48n77IwDTQmVNvkvM-dVf_9c,4435
+c3_otimes_c3/upb/pyramid_UPB.py,sha256=Ba8KCGa5hDUHG3eYNrdRpFU1djJco1s9yrcUpA78nhA,1144
+c3_otimes_c3/upb/tiles_UPB.py,sha256=Mu0r5TpxyDTILAJoTxBm7sYU4zFZ_hoDzxiU3_Si3N0,610
+c4_otimes_c4/__init__.py,sha256=2medfp224azI35nMwsRDFHH0uP8cNnXT5J9TfNvF9IA,39
+c4_otimes_c4/pianni.py,sha256=P8p5u6bk0Uz3nPWkkTbq1mPqmLBMaev0lQ0Z-_S_cHg,1512
+c5_otimes_c5/__init__.py,sha256=2Wf2yfbMM98BgXxUcEvf6jFrCWXZ_VLtwAIJw0eaixc,55
+c5_otimes_c5/sn3_grid_state.py,sha256=NZ4tShUBg-_5Bg60ov2UVsF1ZddZ-c8hYjfPygcSMYU,945
+cd_otimes_cd/__init__.py,sha256=fLSu2xyR619EHtPb2SqPp5JtjRwBtYIIhkls7IDzhvc,105
+cd_otimes_cd/gen_tiles.py,sha256=84ecdzoxKZNXonIh_bW5bPVVcse0jzFL-NW528qgE4A,2507
+cd_otimes_cd/yu_oh.py,sha256=HeyB5LsGgV-Ok961F5O2utY5oJ_lXSwVmS1NB6xUw9I,4043
+cm_otimes_cn/__init__.py,sha256=53-rTyfj6SrIIT2MJaxqvkzj-31RnMmTG4VfKbHdX3U,273
+cm_otimes_cn/gen_tiles.py,sha256=UL8lGq78rXdBGb3S7rC0GHqpm8H6QdsBGKsA7X9wKqw,2906
+cm_otimes_cn/generalized_grid_state.py,sha256=vLcQUX-V6XPZnN5YCsY1DdKUNumaJWnASMs_tSEfHsA,1113
+cm_otimes_cn/grid_state.py,sha256=i2ETuwblBtGM8BGdVn3K9VMxTambJdFJdOn8h264-gE,1202
+cm_otimes_cn/random_not_bound_entangled.py,sha256=bk6e07wqK91CcpkWCN9GLsb1yovcQWY6w6V1liUswEc,1869
+utils/__init__.py,sha256=lclnRF8GVRvHnZRot-razEy066ZGWWZ-FJQSw-QSc1U,58
+utils/ketbra.py,sha256=NShTAaBzEBfOV3lPGUgWB_wiMXmcSG244luNLNGYj1o,314
+utils/upb.py,sha256=09iR5tCah4M1fIojt6335344es9L8LuomrL0kwFSkAs,1042
+bound_entangled-0.1.0.dist-info/METADATA,sha256=atDL_Hbo7vSPbjKvvyBSIOGZddPaLMSpg8wOBU2U70s,4316
+bound_entangled-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+bound_entangled-0.1.0.dist-info/top_level.txt,sha256=r2aBXhUrfTe3MEuDk5Ruz0ISX4dOiUnJdzVh1Att52Y,71
+bound_entangled-0.1.0.dist-info/RECORD,,

bound_entangled-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bound_entangled-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Van Cleemput
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bound_entangled-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+c3_otimes_c3
+c4_otimes_c4
+c5_otimes_c5
+cd_otimes_cd
+cm_otimes_cn
+utils

c3_otimes_c3/__init__.py

@@ -0,0 +1,7 @@
+from c3_otimes_c3.chessboard import chessboard, chessboard_extremal_PPT
+from c3_otimes_c3.cross_hatch import cross_hatch
+from c3_otimes_c3.steering import steering_state
+from c3_otimes_c3.upb.tiles_UPB import tiles_upb
+from c3_otimes_c3.upb.pyramid_UPB import pyramid_upb
+from c3_otimes_c3.upb.parametrized_UPB import parametrized_upb
+from c3_otimes_c3.horodecki import horodecki

c3_otimes_c3/chessboard.py

@@ -0,0 +1,57 @@
+"""https://arxiv.org/abs/quant-ph/9911056
+
+D. Bruß, A. Peres, "Construction of quantum states with bound entanglement",
+Phys. Rev. A 61, 030301(R) (2000). Named "chessboard states" because their
+8x8 matrix form looks like a chessboard (see also
+https://arxiv.org/abs/2010.08372, Appendix C2).
+"""
+
+from toqito.states import chessboard as chessboard_toqito
+from typing import Optional
+import numpy as np
+
+
+def chessboard(
+    a: complex, b: complex, c: complex, d: complex, m: complex, n: complex, s: Optional[complex] = None, t: Optional[complex] = None
+) -> np.ndarray:
+    """A chessboard state.
+
+    Args:
+        a: free real parameter.
+        b: free real parameter.
+        c: free real parameter.
+        d: free real parameter.
+        m: free real parameter.
+        n: free real parameter.
+        s: defaults to c/n if None.
+        t: defaults to a*d/m if None.
+
+    Returns:
+        np.ndarray: a chessboard quantum state.
+    """
+    return chessboard_toqito([a, b, c, d, m, n], s, t)  # type: ignore
+
+
+def chessboard_extremal_PPT() -> np.ndarray:
+    """Extremal PPT chessboard state.
+
+    The state from the chessboard family with m = n = b = -3/5, a = 3/5,
+    c = -d = 6/5, shown to be an extremal point of the PPT-entangled states
+    in https://arxiv.org/abs/2010.08372 (Fig. 2 / Fig. 9, page 25).
+
+    Returns:
+        np.ndarray: the extremal PPT chessboard state.
+    """
+    return chessboard(
+        # m = n = b = -3/5
+        m=-3 / 5,
+        n=-3 / 5,
+        b=-3 / 5,
+        # a = 3/5
+        a=3 / 5,
+        # c = -d = 6/5
+        c=6 / 5,
+        d=-6 / 5,
+        s=(3 / 5) * (6 / 5) / (-3 / 5),
+        t=(3 / 5) * (-6 / 5) / (-3 / 5),
+    )

c3_otimes_c3/cross_hatch.py

@@ -0,0 +1,25 @@
+"""https://arxiv.org/abs/1705.09261
+
+J. Lockhart, O. Gühne, S. Severini, "Entanglement properties of quantum grid
+states", Phys. Rev. A 97, 062340 (2018).
+"""
+
+from cm_otimes_cn.grid_state import grid_state
+
+
+def cross_hatch():
+    """The 3x3 "cross-hatch" grid state.
+
+    A bound entangled example of a quantum grid state, detected by the CCNR
+    (realignment) criterion.
+
+    Returns:
+        np.ndarray: the cross-hatch grid state.
+    """
+    return grid_state(
+        (3, 3),
+        ((0, 0), (1, 2)),
+        ((1, 0), (2, 2)),
+        ((0, 1), (2, 0)),
+        ((0, 2), (2, 1)),
+    )

c3_otimes_c3/horodecki.py

@@ -0,0 +1,23 @@
+"""https://arxiv.org/abs/quant-ph/9703004
+
+P. Horodecki, "Separability criterion and inseparable mixed states with
+positive partial transposition", Phys. Lett. A 232, 333 (1997), Section 4.1.
+One of the first known families of bound entangled states: PPT for every
+a_param in [0, 1], separable only at the endpoints a_param = 0 or 1.
+"""
+
+from toqito.states import horodecki as horodecki_toqito
+import numpy as np
+
+
+def horodecki(a_param: float) -> np.ndarray:
+    """The 3x3 Horodecki state.
+
+    Args:
+        a_param: free real parameter in [0, 1]. The state is PPT for every
+            value in this range, and separable only at a_param = 0 or 1.
+
+    Returns:
+        np.ndarray: the 3x3 Horodecki density matrix.
+    """
+    return horodecki_toqito(a_param, dim=[3, 3])  # type: ignore

c3_otimes_c3/steering.py

@@ -0,0 +1,42 @@
+"""https://arxiv.org/abs/1405.0262
+
+T. Moroder, O. Gittsovich, M. Huber, O. Gühne, "Steering Bound Entangled
+States: A Counterexample to the Stronger Peres Conjecture", Phys. Rev. Lett.
+113, 050404 (2014).
+"""
+
+import numpy as np
+from math import sqrt
+from utils import ketbra
+
+
+def steering_state(m1: float, m2: float) -> np.ndarray:
+    """A 3x3 bound entangled state that is steerable, parametrized by m1, m2.
+
+    Counterexample to the (stronger) Peres conjecture that bound entangled
+    states cannot be used to demonstrate EPR steering.
+
+    Args:
+        m1: first free real parameter.
+        m2: second free real parameter (with m1**2 + m2**2 <= 1).
+
+    Returns:
+        np.ndarray: the steerable bound entangled state.
+    """
+    m3 = sqrt((1 - m1**2 - m2**2) / 2)
+
+    psi_1 = np.zeros(9, dtype=np.float64)
+    psi_2 = np.zeros(9, dtype=np.float64)
+    psi_3 = np.zeros(9, dtype=np.float64)
+    psi_t_3 = np.zeros(9, dtype=np.float64)
+
+    psi_1[1 * 3 + 2], psi_1[2 * 3 + 1] = 1 / sqrt(2), 1 / sqrt(2)
+    psi_2[0], psi_2[1 * 3 + 1], psi_2[2 * 3 + 2] = 1 / sqrt(3), 1 / sqrt(3), -1 / sqrt(3)
+    psi_3[1], psi_3[1 * 3], psi_3[1 * 3 + 1], psi_3[2 * 3 + 2] = m1, m2, m3, m3
+    psi_t_3[2], psi_t_3[2 * 3], psi_t_3[2 * 3 + 1], psi_t_3[1 * 3 + 2] = m1, -m2, m3, -m3
+
+    lambda1 = 1 - (2 + 3 * m1 * m2) / (4 - 2 * m1**2 + m1 * m2 - 2 * m2**2)
+    lambda3 = 1 / (4 - 2 * m1**2 + m1 * m2 - 2 * m2**2)
+    lambda2 = 1 - lambda1 - 2 * lambda3
+
+    return lambda1 * ketbra(psi_1, psi_1) + lambda2 * ketbra(psi_2, psi_2) + lambda3 * (ketbra(psi_3, psi_3) + ketbra(psi_t_3, psi_t_3))

c3_otimes_c3/upb/parametrized_UPB.py

@@ -0,0 +1,159 @@
+"""https://arxiv.org/abs/quant-ph/9908070
+
+D. P. DiVincenzo, T. Mor, P. W. Shor, J. A. Smolin, B. M. Terhal,
+"Unextendible Product Bases, Uncompletable Product Bases and Bound
+Entanglement", Commun. Math. Phys. 238, 379 (2003), Section IV A. A
+six-parameter family of unextendible product bases on C^3 (x) C^3 that
+contains the Pyramid and Tiles UPBs (`pyramid_upb`, `tiles_upb`) as special
+cases.
+"""
+
+from math import cos, sin, sqrt
+
+import numpy as np
+from utils import upb
+
+
+def parametrized_basis(
+    gamma_a: float,
+    teta_a: float,
+    phi_a: float,
+    gamma_b: float,
+    teta_b: float,
+    phi_b: float,
+) -> list[np.ndarray]:
+    """The five product vectors of the six-parameter family of UPBs on C^3 (x) C^3.
+
+    Reduces to the Pyramid UPB for phi_a = phi_b = 0 and teta_a = teta_b =
+    gamma_a = gamma_b = arccos((sqrt(5) - 1) / 2), and to the Tiles UPB for
+    phi_a = phi_b = 0 and teta_a = teta_b = gamma_a = gamma_b = 3*pi/4.
+
+    Args:
+        gamma_a: Alice's gamma angle. Requires cos(gamma_a) != 0 and
+            sin(gamma_a) != 0 for the basis to be unextendible.
+        teta_a: Alice's theta angle. Requires cos(teta_a) != 0 and
+            sin(teta_a) != 0 for the basis to be unextendible.
+        phi_a: Alice's phase angle.
+        gamma_b: Bob's gamma angle, subject to the same restriction as gamma_a.
+        teta_b: Bob's theta angle, subject to the same restriction as teta_a.
+        phi_b: Bob's phase angle.
+
+    Returns:
+        list[np.ndarray]: the five normalized product vectors |a_i> (x) |b_i>
+        forming the unextendible product basis, as column vectors.
+    """
+    N_a = sqrt(cos(gamma_a) ** 2 + sin(gamma_a) ** 2 * cos(teta_a) ** 2)
+    N_b = sqrt(cos(gamma_b) ** 2 + sin(gamma_b) ** 2 * cos(teta_b) ** 2)
+
+    a_0 = np.array(
+        [
+            1,
+            0,
+            0,
+        ],
+        dtype=np.complex128,
+    )
+    a_1 = np.array(
+        [
+            0,
+            1,
+            0,
+        ],
+        dtype=np.complex128,
+    )
+    a_2 = np.array(
+        [
+            cos(teta_a),
+            0,
+            sin(teta_a),
+        ],
+        dtype=np.complex128,
+    )
+    a_3 = np.array(
+        [
+            sin(gamma_a) * sin(teta_a),
+            cos(gamma_a) * np.exp(1j * phi_a),
+            -sin(gamma_a) * cos(teta_a),
+        ],
+        dtype=np.complex128,
+    )
+    a_4 = np.array(
+        [
+            0,
+            sin(gamma_a) * cos(teta_a) * np.exp(1j * phi_a) / N_a,
+            cos(gamma_a) / N_a,
+        ],
+        dtype=np.complex128,
+    )
+
+    b_0 = np.array(
+        [
+            0,
+            1,
+            0,
+        ],
+        dtype=np.complex128,
+    )
+    b_1 = np.array(
+        [
+            sin(gamma_b) * sin(teta_b),
+            cos(gamma_b) * np.exp(1j * phi_b),
+            -sin(gamma_b) * cos(teta_b),
+        ],
+        dtype=np.complex128,
+    )
+    b_2 = np.array(
+        [
+            1,
+            0,
+            0,
+        ],
+        dtype=np.complex128,
+    )
+    b_3 = np.array(
+        [
+            cos(teta_b),
+            0,
+            sin(teta_b),
+        ],
+        dtype=np.complex128,
+    )
+    b_4 = np.array(
+        [
+            0,
+            sin(gamma_b) * cos(teta_b) * np.exp(1j * phi_b) / N_b,
+            cos(gamma_b) / N_b,
+        ],
+        dtype=np.complex128,
+    )
+
+    alice = [a_0, a_1, a_2, a_3, a_4]
+    bob = [b_0, b_1, b_2, b_3, b_4]
+    return [np.kron(a, b).reshape(-1, 1) for a, b in zip(alice, bob)]
+
+
+def parametrized_upb(
+    gamma_a: float,
+    teta_a: float,
+    phi_a: float,
+    gamma_b: float,
+    teta_b: float,
+    phi_b: float,
+) -> np.ndarray:
+    """The bound entangled state built from the six-parameter family of UPBs.
+
+    Args:
+        gamma_a: Alice's gamma angle. Requires cos(gamma_a) != 0 and
+            sin(gamma_a) != 0 for the basis to be unextendible.
+        teta_a: Alice's theta angle. Requires cos(teta_a) != 0 and
+            sin(teta_a) != 0 for the basis to be unextendible.
+        phi_a: Alice's phase angle.
+        gamma_b: Bob's gamma angle, subject to the same restriction as gamma_a.
+        teta_b: Bob's theta angle, subject to the same restriction as teta_a.
+        phi_b: Bob's phase angle.
+
+    Returns:
+        np.ndarray: the bound entangled state on the orthogonal complement of
+        the parametrized unextendible product basis.
+    """
+    return upb(parametrized_basis(gamma_a, teta_a, phi_a, gamma_b, teta_b, phi_b))

c3_otimes_c3/upb/pyramid_UPB.py

@@ -0,0 +1,37 @@
+"""https://arxiv.org/abs/quant-ph/9808030
+
+C. H. Bennett, D. P. DiVincenzo, T. Mor, P. W. Shor, J. A. Smolin, B. M.
+Terhal, "Unextendible Product Bases and Bound Entanglement", Phys. Rev. Lett.
+82, 5385 (1999).
+"""
+
+import numpy as np
+from utils import upb
+
+
+def pyramid_basis() -> list[np.ndarray]:
+    """The five product vectors of the "Pyramid" UPB on C^3 (x) C^3.
+
+    Returns:
+        list[np.ndarray]: the five normalized product vectors forming the
+        Pyramid unextendible product basis, as column vectors.
+    """
+    h = 0.5 * np.sqrt(1 + np.sqrt(5))
+    vecs = []
+    for j in range(5):
+        a = np.array([np.cos(2 * np.pi * j / 5), np.sin(2 * np.pi * j / 5), h])
+        b = np.array([np.cos(4 * np.pi * j / 5), np.sin(4 * np.pi * j / 5), h])
+        a /= np.linalg.norm(a)
+        b /= np.linalg.norm(b)
+        vecs.append(np.kron(a, b).reshape(-1, 1))
+    return vecs
+
+
+def pyramid_upb() -> np.ndarray:
+    """The bound entangled state built from the Pyramid UPB.
+
+    Returns:
+        np.ndarray: the bound entangled state on the orthogonal complement of
+        the Pyramid UPB.
+    """
+    return upb(pyramid_basis())

c3_otimes_c3/upb/tiles_UPB.py

@@ -0,0 +1,20 @@
+"""https://arxiv.org/abs/quant-ph/9808030
+
+C. H. Bennett, D. P. DiVincenzo, T. Mor, P. W. Shor, J. A. Smolin, B. M.
+Terhal, "Unextendible Product Bases and Bound Entanglement", Phys. Rev. Lett.
+82, 5385 (1999).
+"""
+
+import numpy as np
+from toqito.states import tile
+from utils import upb
+
+
+def tiles_upb() -> np.ndarray:
+    """The bound entangled state built from the "Tiles" UPB on C^3 (x) C^3.
+
+    Returns:
+        np.ndarray: the bound entangled state on the orthogonal complement of
+        the Tiles unextendible product basis (`toqito.states.tile`).
+    """
+    return upb([tile(i) for i in range(5)])

c4_otimes_c4/__init__.py

@@ -0,0 +1 @@
+from c4_otimes_c4.pianni import pianni

c4_otimes_c4/pianni.py

@@ -0,0 +1,46 @@
+"""https://arxiv.org/abs/quant-ph/0411095
+
+F. Benatti, R. Floreanini, M. Piani, "Non-decomposable quantum dynamical
+semigroups and bound entangled states", Open Syst. Inf. Dyn. 11, 325 (2004).
+
+Also presented as "the 4x4 bound entangled Piani state" in
+https://arxiv.org/abs/2010.08372 (Appendix C5).
+"""
+
+from toqito.matrices import pauli
+from toqito.states import max_entangled
+from toqito.perms import permute_systems
+import numpy as np
+from utils import ketbra
+
+
+def P_ij(i: int, j: int):
+    """The projector onto the generalized Bell state |Psi_ij> = (1 (x) sigma_i (x) sigma_j)|Psi_4^+>.
+
+    Args:
+        i: index of the first Pauli matrix (0..3).
+        j: index of the second Pauli matrix (0..3).
+
+    Returns:
+        np.ndarray: the rank-1 projector P_ij on C^4 (x) C^4.
+    """
+    sigma_ij = np.kron(np.identity(4), np.kron(pauli(i), pauli(j)))  # type: ignore
+    ket_ij = sigma_ij @ max_entangled(4)
+    return ketbra(ket_ij, ket_ij)
+
+
+def pianni():
+    """The 4x4 bound entangled "Piani" state.
+
+    Uniform mixture of the six projections P_ij for (i, j) in
+    {(0,2), (1,1), (2,3), (3,1), (3,2), (3,3)}, indecomposable and PPT under
+    the bipartition AA'|BB' after regrouping the four underlying qubits.
+
+    Returns:
+        np.ndarray: the 16x16 bound entangled density matrix.
+    """
+    rho = np.zeros((16, 16), dtype=np.complex128)
+    for i, j in [(0, 2), (1, 1), (2, 3), (3, 1), (3, 2), (3, 3)]:
+        rho += P_ij(i, j)
+    rho /= 6
+    return permute_systems(rho, [0, 2, 1, 3])

c5_otimes_c5/__init__.py

@@ -0,0 +1 @@
+from c5_otimes_c5.sn3_grid_state import sn3_grid_state

c5_otimes_c5/sn3_grid_state.py

@@ -0,0 +1,36 @@
+"""https://arxiv.org/abs/2402.12966
+
+R. Krebs, M. Gachechiladze, "High Schmidt number concentration in quantum
+bound entangled states", Result 1 / Appendix B: the smallest known Schmidt
+number 3 (hence "SN3") PPT bound entangled state, in local dimension 5x5.
+"""
+
+from cm_otimes_cn.generalized_grid_state import generalized_grid_state
+
+
+def sn3_grid_state():
+    """The smallest known Schmidt number 3 PPT bound entangled state, in 5x5.
+
+    Returns:
+        np.ndarray: the Schmidt number 3 (SN3) generalized grid state rho_5,5.
+    """
+    return generalized_grid_state(
+        (5, 5),
+        # loops
+        [(0, 0)],
+        [(1, 0)],
+        [(0, 1)],
+        [(4, 1)],
+        [(1, 4)],
+        # double loops
+        [(3, 2)],
+        [(2, 3)],
+        [(3, 2)],
+        [(2, 3)],
+        # edges
+        [(1, 2), (3, 4)],
+        [(2, 1), (4, 3)],
+        [(2, 2), (3, 3)],
+        # hyperedge
+        [(0, 2), (1, 1), (2, 0)],
+    )

cd_otimes_cd/__init__.py

@@ -0,0 +1,2 @@
+from cd_otimes_cd.yu_oh import yu_oh, is_valid_yu_oh_input
+from cd_otimes_cd.gen_tiles import gen_tiles1

cd_otimes_cd/gen_tiles.py

@@ -0,0 +1,73 @@
+"""https://arxiv.org/abs/quant-ph/9908070
+
+D. P. DiVincenzo, T. Mor, P. W. Shor, J. A. Smolin, B. M. Terhal,
+"Unextendible Product Bases, Uncompletable Product Bases and Bound
+Entanglement", Commun. Math. Phys. 238, 379 (2003), Section V B, Theorem 5. A
+"tile" construction generalizing the Tiles UPB (`c3_otimes_c3.tiles_upb`) to
+arbitrary even dimension.
+"""
+
+import numpy as np
+from utils import upb
+
+
+def gen_tiles1_basis(d: int) -> list[np.ndarray]:
+    """The product vectors of the GenTiles1 UPB on C^d (x) C^d.
+
+    Built from d/2 - 1 "vertical" and d/2 - 1 "horizontal" families of tile
+    states (Eqs. 5.4-5.5) plus a "stopper" state (Eq. 5.6), for a total of
+    d^2 - 2d + 1 states.
+
+    Args:
+        d: local dimension of both parties. Must be even and >= 4.
+
+    Returns:
+        list[np.ndarray]: the normalized product vectors forming the
+        GenTiles1 unextendible product basis, as column vectors.
+    """
+    if d < 4 or d % 2 != 0:
+        raise ValueError("d must be even and >= 4")
+
+    omega = np.exp(1j * 4 * np.pi / d)
+    basis = []
+
+    for m in range(1, d // 2):
+        for k in range(d):
+            # |V_mk> = |k> (x) |omega_{m,k+1}>
+            ket_k = np.zeros(d, dtype=np.complex128)
+            ket_k[k] = 1
+            ket_omega = np.zeros(d, dtype=np.complex128)
+            for j in range(d // 2):
+                ket_omega[(j + k + 1) % d] += omega ** (j * m)
+            ket_omega /= np.linalg.norm(ket_omega)
+            basis.append(np.kron(ket_k, ket_omega).reshape(-1, 1))
+
+    for m in range(1, d // 2):
+        for k in range(d):
+            # |H_mk> = |omega_{m,k}> (x) |k>
+            ket_omega = np.zeros(d, dtype=np.complex128)
+            for j in range(d // 2):
+                ket_omega[(j + k) % d] += omega ** (j * m)
+            ket_omega /= np.linalg.norm(ket_omega)
+            ket_k = np.zeros(d, dtype=np.complex128)
+            ket_k[k] = 1
+            basis.append(np.kron(ket_omega, ket_k).reshape(-1, 1))
+
+    # |F> = sum_i sum_j |i> (x) |j>
+    stopper = np.ones(d * d, dtype=np.complex128) / d
+    basis.append(stopper.reshape(-1, 1))
+
+    return basis
+
+
+def gen_tiles1(d: int) -> np.ndarray:
+    """The bound entangled state built from the GenTiles1 UPB on C^d (x) C^d.
+
+    Args:
+        d: local dimension of both parties. Must be even and >= 4.
+
+    Returns:
+        np.ndarray: the bound entangled state on the orthogonal complement of
+        the GenTiles1 unextendible product basis.
+    """
+    return upb(gen_tiles1_basis(d))

cd_otimes_cd/yu_oh.py

@@ -0,0 +1,145 @@
+"""https://arxiv.org/abs/1509.08991
+
+S. Yu, C. H. Oh, "A family of nonlocal bound entangled states", Phys. Rev. A
+95, 032111 (2017).
+"""
+
+from toqito.states import max_entangled
+import numpy as np
+from math import sqrt
+from utils import ketbra
+
+
+def psi_ij(d: int, i: int, j: int):
+    """The antisymmetric basis vector |ij> - |ji> of C^d (x) C^d.
+
+    Args:
+        d: local dimension.
+        i: first index, 0 <= i < d.
+        j: second index, 0 <= j < d.
+
+    Returns:
+        np.ndarray: the (unnormalized) vector |ij> - |ji>.
+    """
+    ket = np.zeros(d * d)
+    ket[i * d + j] = 1
+    ket[j * d + i] = -1
+    return ket
+
+
+def teta_d_gen(d: int):
+    """Generate the family of vectors {theta_p} used to build phi_k, by induction on the dimension.
+
+    Args:
+        d: local dimension.
+
+    Returns:
+        list[np.ndarray]: the d-1 vectors theta_p in C^d.
+    """
+    Teta_d = [
+        np.array([0.0, 1.0] + [0.0] * (d - 2)),
+        np.array([0.0, -1.0] + [0.0] * (d - 2)),
+    ]
+    for di in range(3, d + 1):
+        ket_dm1 = np.zeros(d, dtype=np.float64)
+        ket_dm1[di - 1] = 1.0
+        sqrtddm2 = sqrt(di * (di - 2))
+        Teta_d_new = [(sqrtddm2 * teta_p - ket_dm1) / (di - 1) for teta_p in Teta_d]
+        Teta_d = Teta_d_new + [ket_dm1]
+    return Teta_d
+
+
+def phi_k(d: int, k: int):
+    """Helper vector phi_k used in the construction of the Yu-Oh state.
+
+    Args:
+        d: local dimension.
+        k: index, 1 <= k < d.
+
+    Returns:
+        np.ndarray: the vector phi_k in C^d (x) C^d.
+    """
+    ret = np.zeros(d**2, dtype=np.float64)
+    for teta_p in teta_d_gen(d):
+        innerprod = teta_p[k]
+        ret += np.kron(teta_p, teta_p) * innerprod
+    ret *= ((d - 1) ** (3 / 2)) / (d * sqrt(d - 2))
+    return ret
+
+
+def psi_k(d: int, k: int, x: float, y: float, z: float):
+    """Helper vector psi_k used in the construction of the Yu-Oh state.
+
+    Args:
+        d: local dimension.
+        k: index, 1 <= k < d.
+        x: first free parameter of the Yu-Oh state.
+        y: second free parameter of the Yu-Oh state.
+        z: sqrt(1 - x**2 - y**2).
+
+    Returns:
+        np.ndarray: the vector psi_k in C^d (x) C^d.
+    """
+    ret: np.ndarray = np.zeros(d**2)
+    ret[k] = x
+    ret[k * d] = y
+    ret += z * phi_k(d, k)
+    return ret
+
+
+def yu_oh(d: int, x: float, y: float):
+    """The Yu-Oh nonlocal bound entangled state, for local dimension d >= 3.
+
+    A family of PPT entangled states in C^d (x) C^d, parametrized by (x, y),
+    that violate a Bell inequality (hence are nonlocal despite being bound
+    entangled). See `is_valid_yu_oh_input` for the validity domain of (x, y).
+
+    Args:
+        d: local dimension, d >= 3.
+        x: first free parameter.
+        y: second free parameter.
+
+    Returns:
+        np.ndarray: the Yu-Oh bound entangled state.
+    """
+    assert is_valid_yu_oh_input(d, x, y)
+    z = sqrt(1 - x**2 - y**2)
+    delta = z**2 / (d - 2) - x * y
+    R = d * x * y + (d - 1) * (d - 2) * delta + d - 1
+
+    max_ent_ket: np.ndarray = max_entangled(d) * sqrt(d)  # type: ignore
+    ret = x * y / R * ketbra(max_ent_ket, max_ent_ket)
+
+    psi_ij_sum = np.zeros((d**2, d**2))
+    for j in range(1, d - 1):
+        for i in range(j + 1, d):
+            psi_ij_val = psi_ij(d, i, j)
+            psi_ij_sum += ketbra(psi_ij_val, psi_ij_val)
+    ret += delta / R * psi_ij_sum
+
+    psi_k_sum = np.zeros((d**2, d**2))
+    for k in range(1, d):
+        psi_k_val = psi_k(d, k, x, y, z)
+        psi_k_sum += ketbra(psi_k_val, psi_k_val)
+    ret += psi_k_sum / R
+    return ret
+
+
+def is_valid_yu_oh_input(d: int, x: float, y: float) -> bool:
+    """Whether (x, y) lie in the valid parameter domain for `yu_oh`.
+
+    Args:
+        d: local dimension.
+        x: first free parameter.
+        y: second free parameter.
+
+    Returns:
+        bool: True if x**2 + y**2 <= 1 and the resulting delta is positive.
+    """
+    if x**2 + y**2 > 1:
+        return False
+    z = sqrt(1 - x**2 - y**2)
+    delta = z**2 / (d - 2) - x * y
+    if delta <= 0:
+        return False
+    return True

cm_otimes_cn/__init__.py

@@ -0,0 +1,4 @@
+from cm_otimes_cn.generalized_grid_state import generalized_grid_state
+from cm_otimes_cn.grid_state import grid_state
+from cm_otimes_cn.random_not_bound_entangled import random_NPT, random_PPT, random_PPT_close_to_the_PPT_edge
+from cm_otimes_cn.gen_tiles import gen_tiles2

cm_otimes_cn/gen_tiles.py

@@ -0,0 +1,80 @@
+"""https://arxiv.org/abs/quant-ph/9908070
+
+D. P. DiVincenzo, T. Mor, P. W. Shor, J. A. Smolin, B. M. Terhal,
+"Unextendible Product Bases, Uncompletable Product Bases and Bound
+Entanglement", Commun. Math. Phys. 238, 379 (2003), Section V B, Theorem 6. A
+"tile" construction generalizing the Tiles UPB (`c3_otimes_c3.tiles_upb`) to
+arbitrary m (x) n dimension.
+"""
+
+import numpy as np
+from utils import upb
+
+
+def gen_tiles2_basis(m_n: tuple[int, int]) -> list[np.ndarray]:
+    """The product vectors of the GenTiles2 UPB on C^m (x) C^n.
+
+    Built from m "short" tile states (Eq. 5.9), m * (n - 3) "long" tile
+    states (Eq. 5.10), and a "stopper" state (Eq. 5.11), for a total of
+    m*n - 2m + 1 states.
+
+    Args:
+        m_n: dimensions (m, n) of the C^m (x) C^n bipartite system. Requires
+            n > 3, m >= 3, and n >= m. Note m = n = 3 does not yield a UPB
+            (excluded by n > 3).
+
+    Returns:
+        list[np.ndarray]: the normalized product vectors forming the
+        GenTiles2 unextendible product basis, as column vectors.
+    """
+    m, n = m_n
+    if not (n > 3 and m >= 3 and n >= m):
+        raise ValueError("requires n > 3, m >= 3, and n >= m")
+
+    basis = []
+
+    for j in range(m):
+        # |S_j> = 1/sqrt(2) (|j> - |j+1 mod m>) (x) |j>
+        ket_a = np.zeros(m, dtype=np.complex128)
+        ket_a[j] = 1
+        ket_a[(j + 1) % m] -= 1
+        ket_a /= np.linalg.norm(ket_a)
+        ket_b = np.zeros(n, dtype=np.complex128)
+        ket_b[j] = 1
+        basis.append(np.kron(ket_a, ket_b).reshape(-1, 1))
+
+    omega = np.exp(1j * 2 * np.pi / (n - 2))
+    for j in range(m):
+        ket_a = np.zeros(m, dtype=np.complex128)
+        ket_a[j] = 1
+        for k in range(1, n - 2):
+            # |L_jk> = |j> (x) 1/sqrt(n-2) (sum_{i=0}^{m-3} w^ik |i+j+1 mod m>
+            #                               + sum_{i=m-2}^{n-3} w^ik |i+2>)
+            ket_b = np.zeros(n, dtype=np.complex128)
+            for i in range(m - 2):
+                ket_b[(i + j + 1) % m] += omega ** (i * k)
+            for i in range(m - 2, n - 2):
+                ket_b[i + 2] += omega ** (i * k)
+            ket_b /= np.linalg.norm(ket_b)
+            basis.append(np.kron(ket_a, ket_b).reshape(-1, 1))
+
+    # |F> = 1/sqrt(nm) sum_i sum_j |i> (x) |j>
+    stopper = np.ones(m * n, dtype=np.complex128) / np.sqrt(m * n)
+    basis.append(stopper.reshape(-1, 1))
+
+    return basis
+
+
+def gen_tiles2(m_n: tuple[int, int]) -> np.ndarray:
+    """The bound entangled state built from the GenTiles2 UPB on C^m (x) C^n.
+
+    Args:
+        m_n: dimensions (m, n) of the C^m (x) C^n bipartite system. Requires
+            n > 3, m >= 3, and n >= m. Note m = n = 3 does not yield a UPB
+            (excluded by n > 3).
+
+    Returns:
+        np.ndarray: the bound entangled state on the orthogonal complement of
+        the GenTiles2 unextendible product basis.
+    """
+    return upb(gen_tiles2_basis(m_n))

cm_otimes_cn/generalized_grid_state.py

@@ -0,0 +1,38 @@
+"""https://arxiv.org/abs/2402.12966
+
+R. Krebs, M. Gachechiladze, "High Schmidt number concentration in quantum
+bound entangled states". Generalizes quantum grid states (see
+`cm_otimes_cn.grid_state`) to hyperedges spanning more than two vertices.
+"""
+
+import numpy as np
+from utils import ketbra
+
+
+def grid_component(m_n: tuple[int, int], *ij: tuple[int, int]) -> np.ndarray:
+    m, n = m_n
+    e = np.zeros(m * n)
+    for i, j in ij:
+        if i >= m or j >= n:
+            raise IndexError(f"Vertex ({i},{j}) does not  belong to the graph, m={m}, n={n}")
+        e[i * n + j] += 1
+    return e
+
+
+def generalized_grid_state(m_n: tuple[int, int], *hyperedges: list[tuple[int, int]]):
+    """A generalized grid state
+
+    Args:
+        m_n: grid dimensions (m, n).
+        *hyperedges: each hyperedge is a list of vertices (i, j) it spans.
+
+    Returns:
+        np.ndarray: the generalized grid state on C^m (x) C^n.
+    """
+    m, n = m_n
+    rho = np.zeros((m * n, m * n))
+    for edge in hyperedges:
+        gc = grid_component(m_n, *edge)
+        rho += ketbra(gc, gc)
+    rho /= np.trace(rho)
+    return rho

cm_otimes_cn/grid_state.py

@@ -0,0 +1,42 @@
+"""https://arxiv.org/abs/1705.09261
+
+J. Lockhart, O. Gühne, S. Severini, "Entanglement properties of quantum grid
+states", Phys. Rev. A 97, 062340 (2018).
+"""
+
+import numpy as np
+from math import sqrt
+from utils import ketbra
+
+
+def ket(m_n: tuple[int, int], ij: tuple[int, int]):
+    m, n = m_n
+    i, j = ij
+    z = np.zeros(m * n)
+    if i >= m or j >= n:
+        raise IndexError(f"Vertex ({i},{j}) does not  belong to the graph, m={m}, n={n}")
+    z[i * n + j] = 1
+    return z
+
+
+def grid_component(m_n: tuple[int, int], ij: tuple[int, int], kl: tuple[int, int]) -> np.ndarray:
+    return 1 / sqrt(2) * (ket(m_n, ij) - ket(m_n, kl))
+
+
+def grid_state(m_n: tuple[int, int], *edges: tuple[tuple[int, int], tuple[int, int]]) -> np.ndarray:
+    """A quantum grid state: the uniform mixture of pure states over a set of graph edges.
+
+    Args:
+        m_n: grid dimensions (m, n).
+        *edges: each edge is a pair of vertices ((i, j), (k, l)).
+
+    Returns:
+        np.ndarray: the grid state on C^m (x) C^n.
+    """
+    m, n = m_n
+    ret = np.zeros((m * n, m * n))
+    for ij, kl in edges:
+        gc = grid_component(m_n, ij, kl)
+        ret += ketbra(gc, gc)
+    ret /= len(edges)
+    return ret

cm_otimes_cn/random_not_bound_entangled.py

@@ -0,0 +1,62 @@
+from toqito.rand import random_density_matrix
+from toqito.state_props import is_ppt
+import numpy as np
+
+
+def random_NPT(m_n: tuple[int, int]) -> np.ndarray:
+    """A uniformly random density matrix with a non-positive partial transpose (rejection sampling).
+
+    Args:
+        m_n: dimensions (m, n) of the C^m (x) C^n bipartite system.
+
+    Returns:
+        np.ndarray: a random NPT (hence necessarily entangled) density matrix.
+    """
+    m, n = m_n
+    while True:
+        rho = random_density_matrix(m * n)
+        if not is_ppt(rho, dim=[m, n]):
+            return rho
+
+
+def random_PPT(m_n: tuple[int, int]) -> np.ndarray:
+    """A uniformly random density matrix with a positive partial transpose (rejection sampling).
+
+    Args:
+        m_n: dimensions (m, n) of the C^m (x) C^n bipartite system.
+
+    Returns:
+        np.ndarray: a random PPT density matrix.
+    """
+    m, n = m_n
+    while True:
+        rho = random_density_matrix(m * n)
+        if is_ppt(rho, dim=[m, n]):
+            return rho
+
+
+def random_PPT_close_to_the_PPT_edge(m_n, precision: int) -> np.ndarray:
+    """A random PPT state close to the boundary of the PPT set.
+
+    Obtained by bisecting the segment between a random PPT and a random NPT
+    state: at each step the midpoint replaces whichever endpoint is on its
+    own side, halving the distance to the PPT/NPT boundary.
+
+    Args:
+        m_n: dimensions (m, n) of the C^m (x) C^n bipartite system.
+        precision: number of bisection steps.
+
+    Returns:
+        np.ndarray: a PPT density matrix close to the PPT boundary.
+    """
+    m, n = m_n
+    ppt: np.ndarray = random_PPT(m_n)
+    not_ppt: np.ndarray = random_NPT(m_n)
+
+    for _ in range(precision):
+        temp = (ppt + not_ppt) / 2
+        if is_ppt(temp, dim=[m, n]):
+            ppt = temp
+        else:
+            not_ppt = temp
+    return ppt / np.trace(ppt)

utils/__init__.py

@@ -0,0 +1,2 @@
+from utils.ketbra import ketbra
+from utils.upb import upb

utils/ketbra.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+
+def ketbra(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """The outer product |a><b|.
+
+    Args:
+        a: the "ket" vector.
+        b: the "bra" vector (its complex conjugate is used).
+
+    Returns:
+        np.ndarray: the rank-1 operator |a><b|.
+    """
+    return np.outer(a, b.conj())

utils/upb.py

@@ -0,0 +1,27 @@
+import numpy as np
+from utils import ketbra
+
+
+def upb(basis: list[np.ndarray]) -> np.ndarray:
+    """Bound entangled state built from an unextendible product basis (UPB).
+
+    The uniform mixture over the orthogonal complement of a UPB is PPT (each
+    |v_i><v_i| being a product-state projector, partial transposition leaves
+    it unchanged) yet has no product vector in its range, hence is entangled:
+    a bound entangled state.
+
+    Reference: C. H. Bennett, D. P. DiVincenzo, T. Mor, P. W. Shor, J. A.
+    Smolin, B. M. Terhal, "Unextendible Product Bases and Bound Entanglement",
+    Phys. Rev. Lett. 82, 5385 (1999), https://arxiv.org/abs/quant-ph/9808030
+
+    Args:
+        basis: the product vectors (as column vectors) forming the UPB.
+
+    Returns:
+        np.ndarray: the corresponding bound entangled density matrix.
+    """
+    d_total: int = basis[0].shape[0]
+    rho = np.identity(d_total, dtype=np.complex128)
+    for i in range(len(basis)):
+        rho -= ketbra(basis[i], basis[i])
+    return rho / (d_total - len(basis))