Updates + more pyqpp stuff

Signed-off-by: Vlad Gheorghiu <[email protected]>

Author: vsoftco

CHANGES.md

@@ -34,6 +34,9 @@
   `${CMAKE_BUILD_DIR}`
 - Added benchmarking suite using [Catch2](https://github.com/catchorg/Catch2)
   in ["benchmarks"](https://github.com/softwareQinc/qpp/blob/main/benchmarks)
+- Bugfixes for `qpp::QFT()` and `qpp::TFQ()`
+- Finalized pyqpp, now all Quantum++ functions have corresponding bindings in
+  Python
 
 # Version 6.0 - 14 April 2025
 
@@ -114,8 +117,7 @@
   as we now use Markdown format to keep track of changes in new releases
 - Removed Eigen3, pybind11, and GoogleTest dependencies; if not detected,
   they are installed automatically as build dependencies by CMake
-- Bumped GoogleTest version to HEAD latest, as
-  [recommended by Google](https://github.com/google/googletest?tab=readme-ov-file#live-at-head)
+- Updated GoogleTest to the latest HEAD, as recommended by Google
 - Removed `-DWITH_EXAMPLES` and `-DWITH_UNIT_TESTS` CMake flags. Now both
   `examples` and `unit_tests` CMake targets are enabled.
 - Renamed ["qpp/classes/circuits/circuits.hpp"] to

include/qpp/classes/states.hpp

@@ -287,6 +287,7 @@ class States final : public internal::Singleton<const States> // const Singleton
                        std::sqrt(static_cast<realT>(2.0)));
         z0 << 1, 0;
         z1 << 0, 1;
+
         px0 = x0 * x0.adjoint();
         px1 = x1 * x1.adjoint();
         py0 = y0 * y0.adjoint();

include/qpp/operations.hpp

@@ -3536,7 +3536,7 @@ expr_t<Derived> QFT(const Eigen::MatrixBase<Derived>& A, idx d = 2,
 
     std::vector<idx> subsys(n);
     std::iota(subsys.begin(), subsys.end(), 0);
-    ket result = applyQFT(rA, subsys, d, swap);
+    expr_t<Derived> result = applyQFT(rA, subsys, d, swap);
 
     return result;
 }
@@ -3588,7 +3588,7 @@ expr_t<Derived> TFQ(const Eigen::MatrixBase<Derived>& A, idx d = 2,
 
     std::vector<idx> subsys(n);
     std::iota(subsys.begin(), subsys.end(), 0);
-    ket result = applyTFQ(rA, subsys, d, swap);
+    expr_t<Derived> result = applyTFQ(rA, subsys, d, swap);
 
     return result;
 }

pyqpp/include/pyqpp/classes/states_bind.hpp

@@ -34,25 +34,32 @@ inline void init_classes_states(py::module_& m) {
     using namespace qpp;
 
     auto states = m.def_submodule("states");
-    states.attr("x0") = qpp::st.x0;
-    states.attr("x1") = qpp::st.x1;
-    states.attr("y0") = qpp::st.y0;
-    states.attr("y1") = qpp::st.y1;
-    states.attr("z0") = qpp::st.z0;
-    states.attr("z1") = qpp::st.z1;
+    states.attr("x0") = qpp::cmat(qpp::st.x0);
+    states.attr("x1") = qpp::cmat(qpp::st.x1);
+    states.attr("y0") = qpp::cmat(qpp::st.y0);
+    states.attr("y1") = qpp::cmat(qpp::st.y1);
+    states.attr("z0") = qpp::cmat(qpp::st.z0);
+    states.attr("z1") = qpp::cmat(qpp::st.z1);
 
-    states.attr("b00") = qpp::st.b00;
-    states.attr("b01") = qpp::st.b01;
-    states.attr("b10") = qpp::st.b10;
-    states.attr("b11") = qpp::st.b11;
+    states.attr("px0") = qpp::st.px0;
+    states.attr("px1") = qpp::st.px1;
+    states.attr("py0") = qpp::st.py0;
+    states.attr("py1") = qpp::st.py1;
+    states.attr("pz0") = qpp::st.pz0;
+    states.attr("pz1") = qpp::st.pz1;
+
+    states.attr("b00") = qpp::cmat(qpp::st.b00);
+    states.attr("b01") = qpp::cmat(qpp::st.b01);
+    states.attr("b10") = qpp::cmat(qpp::st.b10);
+    states.attr("b11") = qpp::cmat(qpp::st.b11);
 
     states.attr("pb00") = qpp::st.pb00;
     states.attr("pb01") = qpp::st.pb01;
     states.attr("pb10") = qpp::st.pb10;
     states.attr("pb11") = qpp::st.pb11;
 
-    states.attr("GHZ") = qpp::st.GHZ;
-    states.attr("W") = qpp::st.W;
+    states.attr("GHZ") = qpp::cmat(qpp::st.GHZ);
+    states.attr("W") = qpp::cmat(qpp::st.W);
 
     states.attr("pGHZ") = qpp::st.pGHZ;
     states.attr("pW") = qpp::st.pW;

pyqpp/include/pyqpp/constants_bind.hpp

@@ -29,13 +29,15 @@
 
 #include "pyqpp/pyqpp_common.hpp"
 
-/* Constants from constants.hpp */
+/* Bindings for constants.hpp */
 inline void init_constants(py::module_& m) {
     using namespace qpp;
 
     m.attr("ee") = qpp::ee;
-    m.def("omega", &qpp::omega, "D-th root of unity", py::arg("D"));
+    m.attr("infty") = qpp::infty;
     m.attr("pi") = qpp::pi;
+
+    m.def("omega", &qpp::omega, "D-th root of unity", py::arg("D"));
 }
 
 #endif /* PYQPP_CONSTANTS_BIND_HPP_ */

pyqpp/include/pyqpp/entanglement_bind.hpp

@@ -0,0 +1,119 @@
+/*
+ * This file is part of pyqpp.
+ *
+ * Copyright (c) 2017 - 2025 softwareQ Inc. All rights reserved.
+ *
+ * MIT License
+ *
+ * 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.
+ */
+
+#ifndef PYQPP_ENTANGLEMENT_BIND_HPP_
+#define PYQPP_ENTANGLEMENT_BIND_HPP_
+
+#include "pyqpp/pyqpp_common.hpp"
+
+/* Bindings for entropies.hpp */
+inline void init_entanglement(py::module_& m) {
+    using namespace qpp;
+
+    // --- Schmidt Decomposition and Coefficients ---
+
+    m.def(
+        "schmidtcoeffs",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::schmidtcoeffs(A, dims);
+        },
+        "Schmidt coefficients of the bi-partite pure state A.", py::arg("A"),
+        py::arg("dims"));
+
+    m.def(
+        "schmidtcoeffs",
+        [](const cmat& A, idx d) { return qpp::schmidtcoeffs(A, d); },
+        "Schmidt coefficients of the bi-partite pure state A (uniform "
+        "dimensions).",
+        py::arg("A"), py::arg("d") = 2);
+
+    m.def(
+        "schmidtA",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::schmidtA(A, dims);
+        },
+        "Schmidt basis on Alice side.", py::arg("A"), py::arg("dims"));
+
+    m.def(
+        "schmidtB",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::schmidtB(A, dims);
+        },
+        "Schmidt basis on Bob side.", py::arg("A"), py::arg("dims"));
+
+    m.def(
+        "schmidtprobs",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::schmidtprobs(A, dims);
+        },
+        "Schmidt probabilities (squares of coefficients) of the bi-partite "
+        "pure state A.",
+        py::arg("A"), py::arg("dims"));
+
+    m.def(
+        "schmidt",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::schmidt(A, dims);
+        },
+        "Full Schmidt decomposition: returns tuple(U, V, coeffs, probs).",
+        py::arg("A"), py::arg("dims"));
+
+    // --- Entanglement Measures ---
+
+    m.def(
+        "entanglement",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::entanglement(A, dims);
+        },
+        "von-Neumann entanglement entropy of the bi-partite pure state A.",
+        py::arg("A"), py::arg("dims"));
+
+    m.def(
+        "gconcurrence", [](const cmat& A) { return qpp::gconcurrence(A); },
+        "G-concurrence of the bi-partite pure state A.", py::arg("A"));
+
+    m.def(
+        "negativity",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::negativity(A, dims);
+        },
+        "Negativity of the bi-partite mixed state A.", py::arg("A"),
+        py::arg("dims"));
+
+    m.def(
+        "lognegativity",
+        [](const cmat& A, const std::vector<idx>& dims) {
+            return qpp::lognegativity(A, dims);
+        },
+        "Logarithmic negativity of the bi-partite mixed state A.", py::arg("A"),
+        py::arg("dims"));
+
+    m.def(
+        "concurrence", [](const cmat& A) { return qpp::concurrence(A); },
+        "Wootters concurrence of the bi-partite qubit mixed state A.",
+        py::arg("A"));
+}
+#endif /* PYQPP_ENTANGLEMENT_BIND_HPP_ */

pyqpp/include/pyqpp/entropies_bind.hpp

@@ -0,0 +1,106 @@
+/*
+ * This file is part of pyqpp.
+ *
+ * Copyright (c) 2017 - 2025 softwareQ Inc. All rights reserved.
+ *
+ * MIT License
+ *
+ * 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.
+ */
+
+#ifndef PYQPP_ENTROPIES_BIND_HPP_
+#define PYQPP_ENTROPIES_BIND_HPP_
+
+#include "pyqpp/pyqpp_common.hpp"
+
+/* Bindings for entropies.hpp */
+inline void init_entropies(py::module_& m) {
+    using namespace qpp;
+
+    // --- Entropy Bindings ---
+
+    // von-Neumann entropy (Templated for MatrixBase)
+    m.def(
+        "entropy", [](const cmat& A) { return qpp::entropy(A); },
+        "Computes the von-Neumann entropy of a density matrix (base 2).",
+        py::arg("A"));
+
+    // Shannon entropy (Non-templated, but kept as lambda for consistency)
+    m.def(
+        "entropy",
+        [](const std::vector<realT>& prob) { return qpp::entropy(prob); },
+        "Computes the Shannon entropy of a probability distribution (base 2).",
+        py::arg("prob"));
+
+    // Renyi entropy (Templated for MatrixBase)
+    m.def(
+        "renyi",
+        [](const cmat& A, realT alpha) { return qpp::renyi(A, alpha); },
+        "Computes the Renyi-alpha entropy of a density matrix.", py::arg("A"),
+        py::arg("alpha"));
+
+    // Renyi entropy (Vector version)
+    m.def(
+        "renyi",
+        [](const std::vector<realT>& prob, realT alpha) {
+            return qpp::renyi(prob, alpha);
+        },
+        "Computes the Renyi-alpha entropy of a probability distribution.",
+        py::arg("prob"), py::arg("alpha"));
+
+    // Tsallis entropy (Templated for MatrixBase)
+    m.def(
+        "tsallis", [](const cmat& A, realT q) { return qpp::tsallis(A, q); },
+        "Computes the Tsallis-q entropy of a density matrix.", py::arg("A"),
+        py::arg("q"));
+
+    // Tsallis entropy (Vector version)
+    m.def(
+        "tsallis",
+        [](const std::vector<realT>& prob, realT q) {
+            return qpp::tsallis(prob, q);
+        },
+        "Computes the Tsallis-q entropy of a probability distribution.",
+        py::arg("prob"), py::arg("q"));
+
+    // --- Mutual Information Bindings ---
+
+    // Quantum Mutual Information (Templated, varied dimensions)
+    m.def(
+        "qmutualinfo",
+        [](const cmat& A, const std::vector<idx>& subsysA,
+           const std::vector<idx>& subsysB, const std::vector<idx>& dims) {
+            return qpp::qmutualinfo(A, subsysA, subsysB, dims);
+        },
+        "Computes the quantum mutual information between two subsystems A and "
+        "B with given dimensions.",
+        py::arg("A"), py::arg("subsysA"), py::arg("subsysB"), py::arg("dims"));
+
+    // Quantum Mutual Information (Templated, uniform dimensions)
+    m.def(
+        "qmutualinfo",
+        [](const cmat& A, const std::vector<idx>& subsysA,
+           const std::vector<idx>& subsysB,
+           idx d) { return qpp::qmutualinfo(A, subsysA, subsysB, d); },
+        "Computes the quantum mutual information between two subsystems A and "
+        "B assuming uniform dimensions d.",
+        py::arg("A"), py::arg("subsysA"), py::arg("subsysB"), py::arg("d") = 2);
+}
+
+#endif /* PYQPP_ENTROPIES_BIND_HPP_ */