pennylane-qrack 0.10.9__py3-none-macosx_14_0_arm64.whl → 0.25.0__py3-none-macosx_14_0_arm64.whl

pennylane_qrack/qrack_device.cpp

@@ -6,7 +6,7 @@
 #define CL_HPP_TARGET_OPENCL_VERSION 300
 #include "qrack/qfactory.hpp"
 
-#define QSIM_CONFIG(numQubits) Qrack::CreateArrangedLayersFull(nw, md, sd, sh, bdt, true, tn, true, oc, numQubits, Qrack::ZERO_BCI, nullptr, Qrack::CMPLX_DEFAULT_ARG, false, true, hp)
+#define QSIM_CONFIG(numQubits) Qrack::CreateArrangedLayersFull(nw, md, sd, sh, bdt, pg, tn, hy, oc, numQubits, Qrack::ZERO_BCI, nullptr, Qrack::CMPLX_DEFAULT_ARG, false, true, hp, sp)
 
 std::string trim(std::string s)
 {
@@ -38,9 +38,13 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
     bool md;
     bool bdt;
     bool oc;
+    bool pg;
+    bool hy;
     bool hp;
+    bool sp;
     bool nw;
     size_t shots;
+    Qrack::real1_f noise_param;
     Qrack::QInterfacePtr qsim;
     std::map<QubitIdType, bitLenInt> qubit_map;
     std::vector<QrackObservable> obs_cache;
@@ -184,8 +188,8 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
             const Qrack::real1 omega = inverse ? -params[0U] : params[2U];
             const Qrack::real1 cos0 = (Qrack::real1)cos(theta / 2);
             const Qrack::real1 sin0 = (Qrack::real1)sin(theta / 2);
-            const Qrack::complex expP = exp(Qrack::I_CMPLX * (phi + omega) / (2 * ONE_R1));
-            const Qrack::complex expM = exp(Qrack::I_CMPLX * (phi - omega) / (2 * ONE_R1));
+            const Qrack::complex expP = exp(Qrack::I_CMPLX * (phi + omega) * HALF_R1);
+            const Qrack::complex expM = exp(Qrack::I_CMPLX * (phi - omega) * HALF_R1);
             const Qrack::complex mtrx[4U]{
                 cos0 / expP, -sin0 * expM,
                 sin0 / expM, cos0 * expP
@@ -226,14 +230,12 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         QRACK_CONST Qrack::complex NEG_SQRTI_2_CMPLX(ZERO_R1, -Qrack::SQRT1_2_R1);
         const Qrack::complex QBRTI_2_CMPLX(ZERO_R1, sqrt(Qrack::SQRT1_2_R1));
         const Qrack::complex NEG_QBRTI_2_CMPLX(ZERO_R1, sqrt(-Qrack::SQRT1_2_R1));
-        QRACK_CONST Qrack::complex ONE_PLUS_I_DIV_2 = Qrack::complex((Qrack::real1)(ONE_R1 / 2), (Qrack::real1)(ONE_R1 / 2));
-        QRACK_CONST Qrack::complex ONE_MINUS_I_DIV_2 = Qrack::complex((Qrack::real1)(ONE_R1 / 2), (Qrack::real1)(-ONE_R1 / 2));
 
         QRACK_CONST Qrack::complex pauliX[4U] = { Qrack::ZERO_CMPLX, Qrack::ONE_CMPLX, Qrack::ONE_CMPLX, Qrack::ZERO_CMPLX };
         QRACK_CONST Qrack::complex pauliY[4U] = { Qrack::ZERO_CMPLX, NEG_I_CMPLX, Qrack::I_CMPLX, Qrack::ZERO_CMPLX };
         QRACK_CONST Qrack::complex pauliZ[4U] = { Qrack::ONE_CMPLX, Qrack::ZERO_CMPLX, Qrack::ZERO_CMPLX, NEG_1_CMPLX };
-        QRACK_CONST Qrack::complex sqrtX[4U]{ ONE_PLUS_I_DIV_2, ONE_MINUS_I_DIV_2, ONE_MINUS_I_DIV_2, ONE_PLUS_I_DIV_2 };
-        QRACK_CONST Qrack::complex iSqrtX[4U]{ ONE_MINUS_I_DIV_2, ONE_PLUS_I_DIV_2, ONE_PLUS_I_DIV_2, ONE_MINUS_I_DIV_2 };
+        QRACK_CONST Qrack::complex sqrtX[4U]{ Qrack::HALF_I_HALF_CMPLX, Qrack::HALF_NEG_I_HALF_CMPLX, Qrack::HALF_NEG_I_HALF_CMPLX, Qrack::HALF_I_HALF_CMPLX };
+        QRACK_CONST Qrack::complex iSqrtX[4U]{ Qrack::HALF_NEG_I_HALF_CMPLX, Qrack::HALF_I_HALF_CMPLX, Qrack::HALF_I_HALF_CMPLX, Qrack::HALF_NEG_I_HALF_CMPLX };
         QRACK_CONST Qrack::complex hadamard[4U]{ SQRT1_2_CMPLX, SQRT1_2_CMPLX, SQRT1_2_CMPLX, NEG_SQRT1_2_CMPLX };
 
         if ((name == "PauliX") || (name == "CNOT") || (name == "Toffoli") || (name == "MultiControlledX")) {
@@ -348,8 +350,8 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
             const Qrack::real1 omega = inverse ? -params[0U] : params[2U];
             const Qrack::real1 cos0 = (Qrack::real1)cos(theta / 2);
             const Qrack::real1 sin0 = (Qrack::real1)sin(theta / 2);
-            const Qrack::complex expP = exp(Qrack::I_CMPLX * (phi + omega) / (2 * ONE_R1));
-            const Qrack::complex expM = exp(Qrack::I_CMPLX * (phi - omega) / (2 * ONE_R1));
+            const Qrack::complex expP = exp(Qrack::I_CMPLX * (phi + omega) * HALF_R1);
+            const Qrack::complex expM = exp(Qrack::I_CMPLX * (phi - omega) * HALF_R1);
             const Qrack::complex mtrx[4U]{
                 cos0 / expP, -sin0 * expM,
                 sin0 / expM, cos0 * expP
@@ -384,12 +386,16 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         , sh(true)
         , tn(true)
         , sd(true)
-        , md(true)
+        , md(false)
         , bdt(false)
         , oc(true)
+        , pg(true)
+        , hy(true)
         , hp(false)
+        , sp(false)
         , nw(false)
         , shots(1U)
+        , noise_param(ZERO_R1_F)
         , qsim(nullptr)
     {
         // Cut leading '{' and trailing '}'
@@ -405,11 +411,13 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         keyMap["'is_schmidt_decomposition_parallel'"] = 4;
         keyMap["'is_qbdd'"] = 5;
         keyMap["'is_gpu'"] = 6;
-        keyMap["'is_host_pointer'"] =7;
-        keyMap["'noise'"] = 8;
+        keyMap["'is_paged'"] = 7;
+        keyMap["'is_hybrid_cpu_gpu'"] = 8;
+        keyMap["'is_host_pointer'"] =9;
+        keyMap["'is_sparse'"] =10;
+        keyMap["'noise'"] = 11;
 
         size_t pos;
-        Qrack::real1_f noiseParam = 0;
         while ((pos = kwargs.find(":")) != std::string::npos) {
             std::string key = trim(kwargs.substr(0, pos));
             kwargs.erase(0, pos + 1U);
@@ -437,11 +445,20 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
                     oc =  val;
                     break;
                 case 7:
-                    hp = val;
+                    pg =  val;
                     break;
                 case 8:
-                    noiseParam = std::stof(value);
-                    nw = noiseParam > ZERO_R1;
+                    hy =  val;
+                    break;
+                case 9:
+                    hp = val;
+                    break;
+                case 10:
+                    sp = val;
+                    break;
+                case 11:
+                    noise_param = std::stof(value);
+                    nw = noise_param > ZERO_R1;
                     break;
                 default:
                     break;
@@ -449,8 +466,8 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         }
 
         qsim = QSIM_CONFIG(0U);
-        if (noiseParam > ZERO_R1) {
-            qsim->SetNoiseParameter(noiseParam);
+        if (noise_param > ZERO_R1) {
+            qsim->SetNoiseParameter(noise_param);
         }
     }
 
@@ -472,8 +489,6 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         }
         return ids;
     }
-    [[nodiscard]] auto Zero() const -> Result override { return const_cast<Result>(&QRACK_RESULT_FALSE_CONST); }
-    [[nodiscard]] auto One() const -> Result override { return const_cast<Result>(&QRACK_RESULT_TRUE_CONST); }
     auto Observable(ObsId id, const std::vector<std::complex<double>> &matrix,
                     const std::vector<QubitIdType> &wires) -> ObsIdType override
     {
@@ -544,34 +559,30 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         // Deallocate
         qsim->Dispose(id, 1U);
     }
-    void ReleaseAllQubits() override
+    void ReleaseQubits(const std::vector<QubitIdType> &qubits) override
     {
-        // State vector is left empty
-        qsim = QSIM_CONFIG(0U);
+        if (qubits.size() == qsim->GetQubitCount()) {
+            qsim = QSIM_CONFIG(0U);
+            return;
+        }
+
+        for (const QubitIdType& q : qubits) {
+            ReleaseQubit(q);
+        }
     }
     [[nodiscard]] auto GetNumQubits() const -> size_t override
     {
         return qsim->GetQubitCount();
     }
-    void SetDeviceShots(size_t s) override { shots = s; }
+    void SetDeviceShots(size_t s) override {
+        if ((s > 1U) && (noise_param > ZERO_R1_F)) {
+            throw std::domain_error("Shots > 1 can't be simulated with noise on the Qrack back end! (Likely, you want to set mcm_method=\"one-shot\" on your qnode, with multiple shots.)");
+        }
+        shots = s;
+    }
     [[nodiscard]] auto GetDeviceShots() const -> size_t override { return shots; }
     void StartTapeRecording() override { tapeRecording = true; }
     void StopTapeRecording() override { tapeRecording = false; }
-    void PrintState() override
-    {
-        const size_t numQubits = qsim->GetQubitCount();
-        const size_t maxQPower = (size_t)((uint64_t)qsim->GetMaxQPower());
-        const size_t maxLcv = maxQPower - 1U;
-        size_t idx = 0U;
-        std::cout << "*** State-Vector of Size " << maxQPower << " ***" << std::endl;
-        std::cout << "[";
-        std::unique_ptr<Qrack::complex> sv(new Qrack::complex[maxQPower]);
-        qsim->GetQuantumState(sv.get());
-        for (; idx < maxLcv; ++idx) {
-            std::cout << sv.get()[idx] << ", ";
-        }
-        std::cout << sv.get()[idx] << "]" << std::endl;
-    }
     void NamedOperation(const std::string &name, const std::vector<double> &params,
                         const std::vector<QubitIdType> &wires, bool inverse,
                         const std::vector<QubitIdType> &controlled_wires,
@@ -716,10 +727,14 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
             }
         }
     }
-    void Sample(DataView<double, 2> &samples, size_t shots) override
+    void Sample(DataView<double, 2> &samples) override
     {
         RT_FAIL_IF(samples.size() != shots * qsim->GetQubitCount(), "Invalid size for the pre-allocated samples");
 
+        if ((shots > 1U) && (noise_param > ZERO_R1_F)) {
+            throw std::domain_error("Shots > 1 can't be simulated with noise on the Qrack back end! (Likely, you want to set mcm_method=\"one-shot\" on your qnode, with multiple shots.)");
+        }
+
         if (shots == 1U) {
             const bitCapInt rev_sample = qsim->MAll();
             const bitLenInt numQubits = qsim->GetQubitCount();
@@ -741,10 +756,14 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         const std::map<bitCapInt, int> q_samples = qsim->MultiShotMeasureMask(qPowers, shots);
         _SampleBody(qPowers.size(), q_samples, samples);
     }
-    void PartialSample(DataView<double, 2> &samples, const std::vector<QubitIdType> &wires, size_t shots) override
+    void PartialSample(DataView<double, 2> &samples, const std::vector<QubitIdType> &wires) override
     {
         RT_FAIL_IF(samples.size() != shots * wires.size(), "Invalid size for the pre-allocated samples");
 
+        if ((shots > 1U) && (noise_param > ZERO_R1_F)) {
+            throw std::domain_error("Shots > 1 can't be simulated with noise on the Qrack back end! (Likely, you want to set mcm_method=\"one-shot\" on your qnode, with multiple shots.)");
+        }
+
         auto &&dev_wires = getDeviceWires(wires);
 
         if (shots == 1U) {
@@ -782,8 +801,7 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
             }
         }
     }
-    void Counts(DataView<double, 1> &eigvals, DataView<int64_t, 1> &counts,
-                size_t shots) override
+    void Counts(DataView<double, 1> &eigvals, DataView<int64_t, 1> &counts) override
     {
         const size_t numQubits = qsim->GetQubitCount();
         const size_t numElements = 1U << numQubits;
@@ -817,7 +835,7 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
     }
 
     void PartialCounts(DataView<double, 1> &eigvals, DataView<int64_t, 1> &counts,
-                       const std::vector<QubitIdType> &wires, size_t shots) override
+                       const std::vector<QubitIdType> &wires) override
     {
         const size_t numQubits = wires.size();
         const size_t numElements = 1U << numQubits;
@@ -825,6 +843,10 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         RT_FAIL_IF(eigvals.size() != numElements || counts.size() != numElements,
                    "Invalid size for the pre-allocated counts");
 
+        if ((shots > 1U) && (noise_param > ZERO_R1_F)) {
+            throw std::domain_error("Shots > 1 can't be simulated with noise on the Qrack back end! (Likely, you want to set mcm_method=\"one-shot\" on your qnode, with multiple shots.)");
+        }
+
         auto &&dev_wires = getDeviceWires(wires);
 
         std::map<bitCapInt, int> q_samples;

pennylane_qrack/qrack_device.py

@@ -14,7 +14,6 @@
 """
 Base device class for PennyLane-Qrack.
 """
-from collections import OrderedDict
 from functools import reduce
 import cmath, math
 import os
@@ -24,14 +23,20 @@ import itertools as it
 
 import numpy as np
 
-from pennylane import DeviceError, QuantumFunctionError
+# PennyLane v0.42 introduced the `exceptions` module and will raise
+# deprecation warnings if they are imported from the top-level module.
+
+# This ensures backwards compatibility with older versions of PennyLane.
+try:
+    from pennylane.exceptions import DeviceError, QuantumFunctionError
+except (ModuleNotFoundError, ImportError) as import_error:
+    from pennylane import DeviceError, QuantumFunctionError
+
 from pennylane.devices import QubitDevice
 from pennylane.ops import (
-    QubitStateVector,
+    StatePrep,
     BasisState,
     QubitUnitary,
-    CRZ,
-    PhaseShift,
     Adjoint,
 )
 from pennylane.wires import Wires
@@ -66,9 +71,9 @@ class QrackDevice(QubitDevice):
         "PauliY": Pauli.PauliY,
         "PauliZ": Pauli.PauliZ,
         "Identity": Pauli.PauliI,
+        "Hadamard": None,
+        "Hermitian": None,
         "Prod": None,
-        # "Hadamard": None,
-        # "Hermitian": None,
         # "Sum": None,
         # "SProd": None,
         # "Exp": None,
@@ -141,7 +146,7 @@ class QrackDevice(QubitDevice):
         "C(MultiControlledX)",
     }
 
-    config = pathlib.Path(
+    config_filepath = pathlib.Path(
         os.path.dirname(sys.modules[__name__].__file__) + "/QrackDeviceConfig.toml"
     )
 
@@ -151,14 +156,20 @@ class QrackDevice(QubitDevice):
     isTensorNetwork = True
     # Use Schmidt decomposition optimizations? (Default is "true")
     isSchmidtDecompose = True
-    # Distribute Schmidt-decomposed qubit subsystems to multiple GPUs or accelerators, if available? (Default is "true"; mismatched device capacities might hurt overall performance)
-    isSchmidtDecomposeMulti = True
+    # Distribute Schmidt-decomposed qubit subsystems to multiple GPUs or accelerators, if available? (Default is "False"; mismatched device capacities might hurt overall performance)
+    isSchmidtDecomposeMulti = False
     # Use "quantum binary decision diagram" ("QBDD") methods? (Default is "false"; note that QBDD is CPU-only)
     isBinaryDecisionTree = False
     # Use GPU acceleration? (Default is "true")
     isOpenCL = True
+    # Use multi-GPU (or "multi-page") acceleration? (Default is "true")
+    isPaged = True
+    # Use CPU/GPU method hybridization? (Default is "True")
+    isCpuGpuHybrid = True
     # Allocate GPU buffer from general host heap? (Default is "false"; "true" might improve performance or reliability in certain cases, like if using an Intel HD as accelerator)
-    isHostPointer = False
+    isHostPointer = True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False
+    # For CPU-based simulation, use sparse state vectors (Default is "false")
+    isSparse = False
     # Noise parameter. (Default is "0"; depolarizing noise intensity can also be controlled by "QRACK_GATE_DEPOLARIZATION" environment variable)
     noise = 0
 
@@ -186,8 +197,14 @@ class QrackDevice(QubitDevice):
             self.isBinaryDecisionTree = options["isBinaryDecisionTree"]
         if "isOpenCL" in options:
             self.isOpenCL = options["isOpenCL"]
+        if "isPaged" in options:
+            self.isPaged = options["isPaged"]
+        if "isCpuGpuHybrid" in options:
+            self.isCpuGpuHybrid = options["isCpuGpuHybrid"]
         if "isHostPointer" in options:
             self.isHostPointer = options["isHostPointer"]
+        if "isSparse" in options:
+            self.isSparse = options["isSparse"]
         if "noise" in options:
             self.noise = options["noise"]
             if (self.noise != 0) and (shots is None):
@@ -201,9 +218,24 @@ class QrackDevice(QubitDevice):
             isSchmidtDecompose=self.isSchmidtDecompose,
             isBinaryDecisionTree=self.isBinaryDecisionTree,
             isOpenCL=self.isOpenCL,
+            isCpuGpuHybrid=self.isCpuGpuHybrid,
             isHostPointer=self.isHostPointer,
+            isSparse=self.isSparse,
             noise=self.noise,
         )
+        self.device_kwargs = {
+            "is_hybrid_stabilizer": self.isStabilizerHybrid,
+            "is_tensor_network": self.isTensorNetwork,
+            "is_schmidt_decompose": self.isSchmidtDecompose,
+            "is_schmidt_decompose_parallel": self.isSchmidtDecomposeMulti,
+            "is_qpdd": self.isBinaryDecisionTree,
+            "is_gpu": self.isOpenCL,
+            "is_paged": self.isPaged,
+            "is_hybrid_cpu_gpu": self.isCpuGpuHybrid,
+            "is_host_pointer": self.isHostPointer,
+            "is_sparse": self.isSparse,
+            "noise": self.noise,
+        }
         self._circuit = []
 
     def _reverse_state(self):
@@ -229,8 +261,8 @@ class QrackDevice(QubitDevice):
 
     def _apply(self):
         for op in self._circuit:
-            if isinstance(op, QubitStateVector):
-                self._apply_qubit_state_vector(op)
+            if isinstance(op, StatePrep):
+                self._apply_state_prep(op)
             elif isinstance(op, BasisState):
                 self._apply_basis_state(op)
             elif isinstance(op, QubitUnitary):
@@ -259,7 +291,7 @@ class QrackDevice(QubitDevice):
 
         return state_vector.flatten()
 
-    def _apply_qubit_state_vector(self, op):
+    def _apply_state_prep(self, op):
         """Initialize state with a state vector"""
         wires = op.wires
         input_state = op.parameters[0]
@@ -692,10 +724,11 @@ class QrackDevice(QubitDevice):
 
             return self._samples
 
-        samples = np.array(
-            self._state.measure_shots(list(range(self.num_wires - 1, -1, -1)), self.shots)
+        # QubitDevice.states_to_binary() doesn't work for >64qb. (Fix by Elara, the custom OpenAI GPT)
+        samples = self._state.measure_shots(list(range(self.num_wires - 1, -1, -1)), self.shots)
+        self._samples = np.array(
+            [list(format(b, f"0{self.num_wires}b")) for b in samples], dtype=np.int8
         )
-        self._samples = QubitDevice.states_to_binary(samples, self.num_wires)
 
         return self._samples