pennylane-qrack 0.21.2__py3-none-macosx_15_0_arm64.whl → 0.22.1__py3-none-macosx_15_0_arm64.whl

pennylane_qrack/QrackStabilizerDeviceConfig.toml

@@ -0,0 +1,99 @@
+schema = 3
+
+# The set of all gate types supported at the runtime execution interface of the
+# device, i.e., what is supported by the `execute` method. The gate definitions
+# should have the following format:
+#
+#   GATE = { properties = [ PROPS ], conditions = [ CONDS ] }
+#
+# where PROPS and CONS are zero or more comma separated quoted strings.
+#
+# PROPS: additional support provided for each gate.
+#        - "controllable": if a controlled version of this gate is supported.
+#        - "invertible": if the adjoint of this operation is supported.
+#        - "differentiable": if device gradient is supported for this gate.
+# CONDS: constraints on the support for each gate.
+#        - "analytic" or "finiteshots": if this operation is only supported in
+#          either analytic execution or with shots, respectively.
+#
+[operators.gates]
+
+PauliX                  = { properties = [ "controllable", "invertible" ] }
+PauliY                  = { properties = [ "controllable", "invertible" ] }
+PauliZ                  = { properties = [ "controllable", "invertible" ] }
+Hadamard                = { properties = [ "invertible" ] }
+S                       = { properties = [ "invertible" ] }
+CNOT                    = { properties = [ "invertible" ] }
+SWAP                    = { properties = [ "invertible" ] }
+ISWAP                   = { properties = [ "invertible" ] }
+PSWAP                   = { properties = [ "invertible" ] }
+CY                      = { properties = [ "invertible" ] }
+CZ                      = { properties = [ "invertible" ] }
+Identity                = { properties = [ "controllable", "invertible" ] }
+
+# Observables supported by the device for measurements. The observables defined
+# in this section should have the following format:
+#
+#   OBSERVABLE = { conditions = [ CONDS ] }
+#
+# where CONDS is zero or more comma separated quoted strings, same as above.
+#
+# CONDS: constraints on the support for each observable.
+#        - "analytic" or "finiteshots": if this observable is only supported in
+#          either analytic execution or with shots, respectively.
+#        - "terms-commute": if a composite operator is only supported under the
+#          condition that its terms commute.
+#
+[operators.observables]
+
+PauliX = {}
+PauliY = {}
+PauliZ = {}
+Identity = {}
+Prod = {}
+# Hadamard = {}
+# Hermitian = {}
+# Projector = {}
+# SparseHamiltonian = {}
+# Hamiltonian = {}
+# Sum = {}
+# SProd = {}
+# Exp = {}
+
+# Types of measurement processes supported on the device. The measurements in
+# this section should have the following format:
+#
+#   MEASUREMENT_PROCESS = { conditions = [ CONDS ] }
+#
+# where CONDS is zero or more comma separated quoted strings, same as above.
+#
+# CONDS: constraints on the support for each measurement process.
+#        - "analytic" or "finiteshots": if this measurement is only supported
+#          in either analytic execution or with shots, respectively.
+#
+[measurement_processes]
+
+ExpectationMP   = { conditions = [ "analytic" ] }
+VarianceMP      = { conditions = [ "analytic" ] }
+ProbabilityMP   = { conditions = [ "analytic" ] }
+StateMP         = { conditions = [ "analytic" ] }
+SampleMP        = { conditions = [ "finiteshots" ] }
+CountsMP        = { conditions = [ "finiteshots" ] }
+
+# Additional support that the device may provide that informs the compilation
+# process. All accepted fields and their default values are listed below.
+[compilation]
+
+# Whether the device is compatible with qjit.
+qjit_compatible = false
+
+# Whether the device requires run time generation of the quantum circuit.
+runtime_code_generation = false
+
+# Whether the device supports allocating and releasing qubits during execution.
+dynamic_qubit_management = false
+
+# The methods of handling mid-circuit measurements that the device supports,
+# e.g., "one-shot", "tree-traversal", "device", etc. An empty list indicates
+# that the device does not support mid-circuit measurements.
+supported_mcm_methods = [ "device", "one-shot" ]

pennylane_qrack/_version.py

@@ -16,4 +16,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.21.2"
+__version__ = "0.22.1"

pennylane_qrack/qrack_ace_device.py

@@ -51,7 +51,7 @@ tolerance = 1e-10
 class QrackAceDevice(QubitDevice):
     """Qrack Ace device"""
 
-    name = "Qrack device"
+    name = "Qrack Ace device"
     short_name = "qrack.ace"
     pennylane_requires = ">=0.11.0"
     version = __version__

pennylane_qrack/qrack_stabilizer_device.py

@@ -0,0 +1,296 @@
+# Copyright 2020 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Base device class for PennyLane-Qrack.
+"""
+from functools import reduce
+import cmath, math
+import os
+import pathlib
+import sys
+import itertools as it
+
+import numpy as np
+
+# 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 (
+    BasisState,
+    Adjoint,
+)
+from pennylane.wires import Wires
+
+from pyqrack import QrackStabilizer, Pauli
+
+from ._version import __version__
+from sys import platform as _platform
+
+# tolerance for numerical errors
+tolerance = 1e-10
+
+
+class QrackStabilizerDevice(QubitDevice):
+    """Qrack Stabilizer device"""
+
+    name = "Qrack stabilizer device"
+    short_name = "qrack.stabilizer"
+    pennylane_requires = ">=0.11.0"
+    version = __version__
+    author = "Daniel Strano, adapted from Steven Oud and Xanadu"
+
+    _capabilities = {
+        "model": "qubit",
+        "tensor_observables": True,
+        "inverse_operations": True,
+        "returns_state": True,
+    }
+
+    _observable_map = {
+        "PauliX": Pauli.PauliX,
+        "PauliY": Pauli.PauliY,
+        "PauliZ": Pauli.PauliZ,
+        "Identity": Pauli.PauliI,
+        "Hadamard": None,
+        "Hermitian": None,
+        "Prod": None,
+        # "Sum": None,
+        # "SProd": None,
+        # "Exp": None,
+        # "Projector": None,
+        # "Hamiltonian": None,
+        # "SparseHamiltonian": None
+    }
+
+    observables = _observable_map.keys()
+    operations = {
+        "Identity",
+        "C(Identity)",
+        "SWAP",
+        "ISWAP",
+        "PSWAP",
+        "CNOT",
+        "CY",
+        "CZ",
+        "S",
+        "PauliX",
+        "C(PauliX)",
+        "PauliY",
+        "C(PauliY)",
+        "PauliZ",
+        "C(PauliZ)",
+        "Hadamard",
+        "SX",
+    }
+
+    config_filepath = pathlib.Path(
+        os.path.dirname(sys.modules[__name__].__file__) + "/QrackStabilizerDeviceConfig.toml"
+    )
+
+    def __init__(self, wires=0, shots=None, **kwargs):
+        super().__init__(wires=wires, shots=shots)
+        self.shots = shots
+        self._state = QrackStabilizer(self.num_wires)
+        self.device_kwargs = {}
+
+    def _reverse_state(self):
+        end = self.num_wires - 1
+        mid = self.num_wires >> 1
+        for i in range(mid):
+            self._state.swap(i, end - i)
+
+    def apply(self, operations, **kwargs):
+        for op in operations:
+            if isinstance(op, BasisState):
+                self._apply_basis_state(op)
+            else:
+                self._apply_gate(op)
+
+    def _apply_basis_state(self, op):
+        """Initialize a basis state"""
+        wires = self.map_wires(Wires(op.wires))
+        par = op.parameters[0]
+        wire_count = len(wires)
+        n_basis_state = len(par)
+
+        if not set(par).issubset({0, 1}):
+            raise ValueError("BasisState parameter must consist of 0 or 1 integers.")
+        if n_basis_state != wire_count:
+            raise ValueError("BasisState parameter and wires must be of equal length.")
+
+        for i in range(wire_count):
+            index = wires.labels[i]
+            if par[i] != self._state.m(index):
+                self._state.x(index)
+
+    def _apply_gate(self, op):
+        """Apply native qrack gate"""
+
+        opname = op.name
+        if isinstance(op, Adjoint):
+            op = op.base
+            opname = op.name + ".inv"
+
+        par = op.parameters
+
+        # translate op wire labels to consecutive wire labels used by the device
+        device_wires = self.map_wires(
+            (op.control_wires + op.wires) if op.control_wires else op.wires
+        )
+
+        if opname in [
+            "".join(p)
+            for p in it.product(
+                [
+                    "CNOT",
+                    "C(PauliX)",
+                ],
+                ["", ".inv"],
+            )
+        ]:
+            self._state.mcx(device_wires.labels[:-1], device_wires.labels[-1])
+        elif opname in ["C(PauliY)", "C(PauliY).inv"]:
+            self._state.mcy(device_wires.labels[:-1], device_wires.labels[-1])
+        elif opname in ["C(PauliZ)", "C(PauliZ).inv"]:
+            self._state.mcz(device_wires.labels[:-1], device_wires.labels[-1])
+        elif opname in ["SWAP", "SWAP.inv"]:
+            self._state.swap(device_wires.labels[0], device_wires.labels[1])
+        elif opname == "ISWAP":
+            self._state.iswap(device_wires.labels[0], device_wires.labels[1])
+        elif opname == "ISWAP.inv":
+            self._state.adjiswap(device_wires.labels[0], device_wires.labels[1])
+        elif opname in ["CY", "CY.inv", "C(CY)", "C(CY).inv"]:
+            self._state.mcy(device_wires.labels[:-1], device_wires.labels[-1])
+        elif opname in ["CZ", "CZ.inv", "C(CZ)", "C(CZ).inv"]:
+            self._state.mcz(device_wires.labels[:-1], device_wires.labels[-1])
+        elif opname == "S":
+            for label in device_wires.labels:
+                self._state.s(label)
+        elif opname == "S.inv":
+            for label in device_wires.labels:
+                self._state.adjs(label)
+        elif opname in ["PauliX", "PauliX.inv"]:
+            for label in device_wires.labels:
+                self._state.x(label)
+        elif opname in ["PauliY", "PauliY.inv"]:
+            for label in device_wires.labels:
+                self._state.y(label)
+        elif opname in ["PauliZ", "PauliZ.inv"]:
+            for label in device_wires.labels:
+                self._state.z(label)
+        elif opname in ["Hadamard", "Hadamard.inv"]:
+            for label in device_wires.labels:
+                self._state.h(label)
+        elif opname == "SX":
+            half_pi = math.pi / 2
+            for label in device_wires.labels:
+                self._state.u(label, half_pi, -half_pi, half.pi)
+        elif opname == "SX.inv":
+            half_pi = math.pi / 2
+            for label in device_wires.labels:
+                self._state.u(label, -half_pi, -half.pi, half_pi)
+        elif opname not in [
+            "Identity",
+            "Identity.inv",
+            "C(Identity)",
+            "C(Identity).inv",
+        ]:
+            raise DeviceError(f"Operation {opname} is not supported on a {self.short_name} device.")
+
+    def analytic_probability(self, wires=None):
+        """Return the (marginal) analytic probability of each computational basis state."""
+        if self._state is None:
+            return None
+
+        all_probs = self._abs(self.state) ** 2
+        prob = self.marginal_prob(all_probs, wires)
+
+        if (not "QRACK_FPPOW" in os.environ) or (6 > int(os.environ.get("QRACK_FPPOW"))):
+            tot_prob = 0
+            for p in prob:
+                tot_prob = tot_prob + p
+
+            if tot_prob != 1.0:
+                for i in range(len(prob)):
+                    prob[i] = prob[i] / tot_prob
+
+        return prob
+
+    def expval(self, observable, **kwargs):
+        if self.shots is None:
+            if isinstance(observable.name, list):
+                b = [self._observable_map[obs] for obs in observable.name]
+            elif observable.name == "Prod":
+                b = [self._observable_map[obs.name] for obs in observable.operands]
+            else:
+                b = [self._observable_map[observable.name]]
+
+            if None not in b:
+                q = self.map_wires(observable.wires)
+                return self._state.pauli_expectation(q, b)
+
+            # exact expectation value
+            if callable(observable.eigvals):
+                eigvals = self._asarray(observable.eigvals(), dtype=self.R_DTYPE)
+            else:  # older version of pennylane
+                eigvals = self._asarray(observable.eigvals, dtype=self.R_DTYPE)
+            prob = self.probability(wires=observable.wires)
+            return self._dot(eigvals, prob)
+
+        # estimate the ev
+        return np.mean(self.sample(observable))
+
+    def _generate_sample(self):
+        rev_sample = self._state.m_all()
+        sample = 0
+        for i in range(self.num_wires):
+            if (rev_sample & (1 << i)) > 0:
+                sample |= 1 << (self.num_wires - (i + 1))
+        return sample
+
+    def generate_samples(self):
+        if self.shots is None:
+            raise QuantumFunctionError(
+                "The number of shots has to be explicitly set on the device "
+                "when using sample-based measurements."
+            )
+
+            return self._samples
+
+        if self.shots == 1:
+            self._samples = QubitDevice.states_to_binary(
+                np.array([self._generate_sample()]), self.num_wires
+            )
+
+            return self._samples
+
+        # 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
+        )
+
+        return self._samples
+
+    def reset(self):
+        for i in range(self.num_wires):
+            if self._state.m(i):
+                self._state.x(i)

{pennylane_qrack-0.21.2.dist-info → pennylane_qrack-0.22.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pennylane-qrack
-Version: 0.21.2
+Version: 0.22.1
 Summary: PennyLane plugin for Qrack.
 Home-page: http://github.com/vm6502q
 Maintainer: vm6502q
@@ -65,7 +65,8 @@ Features
 
 * Provides access to a PyQrack simulator backend via the ``qrack.simulator`` device
 * Provides access to a (C++) Qrack simulator backend for Catalyst (also) via the ``qrack.simulator`` device
-* Provides access to a PyQrack simulator backend optimized for approximate NISQ-scale TFIM via the ``qrack.ace`` device
+* Provides access to a PyQrack Clifford-only simulator backend via the ``qrack.stabilizer`` device
+* Provides access to a PyQrack simulator backend optimized for large-scale approximate simulation via the ``qrack.ace`` device
 
 .. installation-start-inclusion-marker-do-not-remove
 

pennylane_qrack-0.22.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+pennylane_qrack/CMakeCache.txt,sha256=RHCB8EgzGD7nE0HG-46wFEyVI4ufQ5_LhzvvjnHCTyk,15091
+pennylane_qrack/Makefile,sha256=HMf2JV8WoMeW-rN8dAbzA3ssXMIzvgCPyJO-NvdJwPw,7618
+pennylane_qrack/QrackAceDeviceConfig.toml,sha256=KmPPJEa6TMYpbQqQgMSAPfeGPQE8f1lriteyfGW8WeA,4517
+pennylane_qrack/QrackDeviceConfig.toml,sha256=oR9-dIAP6BzP3e2QSLroacaloHZsx7iJiKE6w7LGxUo,5459
+pennylane_qrack/QrackStabilizerDeviceConfig.toml,sha256=zm2M2FBR--RnKkNCtZih7xxtr-Vl6MtI4g1L3SrjFWw,3965
+pennylane_qrack/__init__.py,sha256=_g4NKu07_pXqxvQaxjdAPe769S5tWwYjqyHi3z7YKHc,673
+pennylane_qrack/_version.py,sha256=TuMQbEShSB_Ma6Dwc0Xzs4HGrkgaiFBKfcSzPHrTCRg,689
+pennylane_qrack/cmake_install.cmake,sha256=ZhG9tI7bh8oZnfUnP0eAVtodPUizqINLahqbb_TXwxY,3108
+pennylane_qrack/libqrack_device.dylib,sha256=N_vWWDurPIomt5Wi9H77Z62sgBAjYr-aDozvL6o5G_Y,3240760
+pennylane_qrack/qrack_ace_device.py,sha256=RaD2nxFSW6mW1pu19FDaI5CJx3s9D1K3-5VHjwzsBcM,17093
+pennylane_qrack/qrack_device.cpp,sha256=FFP1GLdgqOho9irwdaAF1Lo1T9KIsaVKMiiIglkrOmE,37194
+pennylane_qrack/qrack_device.py,sha256=LkfoH_KHm8VcUNT6Xzo3NZE24iGUMcLz8f1Nk8Jp6Sk,28358
+pennylane_qrack/qrack_stabilizer_device.py,sha256=owS6GZqob8B5wU7JqEbIlJ47-RqQPlkJUDBa65YJTVw,9958
+pennylane_qrack-0.22.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pennylane_qrack-0.22.1.dist-info/METADATA,sha256=Jyn8lgvGVPvs3nSM7NwLNDm3R3CeFLLo0j3rH4PoNuc,6181
+pennylane_qrack-0.22.1.dist-info/WHEEL,sha256=tt4-VHVHv-wywtMZy9Hvv8M6zRlbacCdJyvDZp-_L0E,105
+pennylane_qrack-0.22.1.dist-info/entry_points.txt,sha256=5eoa4LFV7DuSLFbs6tzFvuVIHr6zOovxqlDsn2cinP4,220
+pennylane_qrack-0.22.1.dist-info/top_level.txt,sha256=5NFMNHqCHtVLwNkLg66xz846uUJAlnOJ5VGa6ulW1ow,16
+pennylane_qrack-0.22.1.dist-info/RECORD,,

{pennylane_qrack-0.21.2.dist-info → pennylane_qrack-0.22.1.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [pennylane.plugins]
 qrack.ace = pennylane_qrack.qrack_ace_device:QrackAceDevice
 qrack.simulator = pennylane_qrack.qrack_device:QrackDevice
+qrack.stabilizer = pennylane_qrack.qrack_stabilizer_device:QrackStabilizerDevice

pennylane_qrack-0.21.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-pennylane_qrack/CMakeCache.txt,sha256=RHCB8EgzGD7nE0HG-46wFEyVI4ufQ5_LhzvvjnHCTyk,15091
-pennylane_qrack/Makefile,sha256=HMf2JV8WoMeW-rN8dAbzA3ssXMIzvgCPyJO-NvdJwPw,7618
-pennylane_qrack/QrackAceDeviceConfig.toml,sha256=KmPPJEa6TMYpbQqQgMSAPfeGPQE8f1lriteyfGW8WeA,4517
-pennylane_qrack/QrackDeviceConfig.toml,sha256=oR9-dIAP6BzP3e2QSLroacaloHZsx7iJiKE6w7LGxUo,5459
-pennylane_qrack/__init__.py,sha256=_g4NKu07_pXqxvQaxjdAPe769S5tWwYjqyHi3z7YKHc,673
-pennylane_qrack/_version.py,sha256=sHFnioqyJ4bxJJ7wbD1RCSm_tJqIQXYUoAXGyqK359M,689
-pennylane_qrack/cmake_install.cmake,sha256=ZhG9tI7bh8oZnfUnP0eAVtodPUizqINLahqbb_TXwxY,3108
-pennylane_qrack/libqrack_device.dylib,sha256=Q8ce8Y_xwXDw2CmD2ULb_mtX641tewaMcDuY1pJ08DU,3237624
-pennylane_qrack/qrack_ace_device.py,sha256=XXm3_FSTZGzMyhafX0UnSEda9EVtC2x_Mm9nZxTMqJc,17089
-pennylane_qrack/qrack_device.cpp,sha256=FFP1GLdgqOho9irwdaAF1Lo1T9KIsaVKMiiIglkrOmE,37194
-pennylane_qrack/qrack_device.py,sha256=LkfoH_KHm8VcUNT6Xzo3NZE24iGUMcLz8f1Nk8Jp6Sk,28358
-pennylane_qrack-0.21.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pennylane_qrack-0.21.2.dist-info/METADATA,sha256=yaDoSN3SexTPwVlS9hqRNINzWVN_N-sxijq9Wiab_Zs,6075
-pennylane_qrack-0.21.2.dist-info/WHEEL,sha256=tt4-VHVHv-wywtMZy9Hvv8M6zRlbacCdJyvDZp-_L0E,105
-pennylane_qrack-0.21.2.dist-info/entry_points.txt,sha256=OrkJ6JVk-yndlQjqc-8dm8PxE-jNoNQRFXFeUBxVuCg,139
-pennylane_qrack-0.21.2.dist-info/top_level.txt,sha256=5NFMNHqCHtVLwNkLg66xz846uUJAlnOJ5VGa6ulW1ow,16
-pennylane_qrack-0.21.2.dist-info/RECORD,,