pennylane-qrack 0.8.1__tar.gz → 0.8.4__tar.gz

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4}/Makefile

@@ -24,7 +24,7 @@ help:
 build-deps:
 ifneq ($(OS),Windows_NT)
 ifeq ($(QRACK_PRESENT),)
-	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout a73d1e66272ab24cdee1e4a386702951474b4e69; cd ..
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout 99de260f9df4f91565fb3ffc2f2bacd7385e09f2; cd ..
 endif
 	mkdir -p qrack/build
 ifeq ($(UNAME_S),Linux)

{pennylane_qrack-0.8.1/pennylane_qrack.egg-info → pennylane_qrack-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pennylane-qrack
-Version: 0.8.1
+Version: 0.8.4
 Summary: PennyLane plugin for Qrack.
 Home-page: http://github.com/vm6502q
 Maintainer: vm6502q

pennylane_qrack-0.8.4/catalyst/runtime/include/DataView.hpp

@@ -0,0 +1,147 @@
+// Copyright 2023 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.
+
+#pragma once
+
+#include <Exception.hpp>
+
+/**
+ * A multi-dimensional view for MemRef-like and std::vector<T> types.
+ *
+ * @tparam T The underlying data type
+ * @tparam R The Rank (R > 0)
+ *
+ * @note A forward iterator is implemented in this view for traversing over the entire
+ * elements of MemRef types rank-by-rank starting from the last dimension (R-1). For example,
+ * The DataView iterator for MemRef<T, 2> starts from index (0, 0) and traverses elements
+ * in the following order:
+ * (0, 0), ..., (0, sizes[1]-1), (1, 0), ..., (1, sizes[1]-1), ... (sizes[0]-1, sizes[1]-1).
+ */
+template <typename T, size_t R> class DataView {
+  private:
+    T *data_aligned;
+    size_t offset;
+    size_t sizes[R] = {0};
+    size_t strides[R] = {0};
+
+  public:
+    class iterator {
+      private:
+        const DataView<T, R> &view;
+
+        int64_t loc; // physical index
+        size_t indices[R] = {0};
+
+      public:
+        using iterator_category = std::forward_iterator_tag; // LCOV_EXCL_LINE
+        using value_type = T;                                // LCOV_EXCL_LINE
+        using difference_type = std::ptrdiff_t;              // LCOV_EXCL_LINE
+        using pointer = T *;                                 // LCOV_EXCL_LINE
+        using reference = T &;                               // LCOV_EXCL_LINE
+
+        iterator(const DataView<T, R> &_view, int64_t begin_idx) : view(_view), loc(begin_idx) {}
+        pointer operator->() const { return &view.data_aligned[loc]; }
+        reference operator*() const { return view.data_aligned[loc]; }
+        iterator &operator++()
+        {
+            int64_t next_axis = -1;
+            int64_t idx;
+            for (int64_t i = R; i > 0; --i) {
+                idx = i - 1;
+                if (indices[idx]++ < view.sizes[idx] - 1) {
+                    next_axis = idx;
+                    break;
+                }
+                indices[idx] = 0;
+                loc -= (view.sizes[idx] - 1) * view.strides[idx];
+            }
+
+            loc = next_axis == -1 ? -1 : loc + view.strides[next_axis];
+            return *this;
+        }
+        iterator operator++(int)
+        {
+            auto tmp = *this;
+            int64_t next_axis = -1;
+            int64_t idx;
+            for (int64_t i = R; i > 0; --i) {
+                idx = i - 1;
+                if (indices[idx]++ < view.sizes[idx] - 1) {
+                    next_axis = idx;
+                    break;
+                }
+                indices[idx] = 0;
+                loc -= (view.sizes[idx] - 1) * view.strides[idx];
+            }
+
+            loc = next_axis == -1 ? -1 : loc + view.strides[next_axis];
+            return tmp;
+        }
+        bool operator==(const iterator &other) const
+        {
+            return (loc == other.loc && view.data_aligned == other.view.data_aligned);
+        }
+        bool operator!=(const iterator &other) const { return !(*this == other); }
+    };
+
+    explicit DataView(std::vector<T> &buffer) : data_aligned(buffer.data()), offset(0)
+    {
+        static_assert(R == 1, "[Class: DataView] Assertion: R == 1");
+        sizes[0] = buffer.size();
+        strides[0] = 1;
+    }
+
+    explicit DataView(T *_data_aligned, size_t _offset, size_t *_sizes, size_t *_strides)
+        : data_aligned(_data_aligned), offset(_offset)
+    {
+        static_assert(R > 0, "[Class: DataView] Assertion: R > 0");
+        if (_sizes && _strides) {
+            for (size_t i = 0; i < R; i++) {
+                sizes[i] = _sizes[i];
+                strides[i] = _strides[i];
+            }
+        } // else sizes = {0}, strides = {0}
+    }
+
+    [[nodiscard]] auto size() const -> size_t
+    {
+        if (!data_aligned) {
+            return 0;
+        }
+
+        size_t tsize = 1;
+        for (size_t i = 0; i < R; i++) {
+            tsize *= sizes[i];
+        }
+        return tsize;
+    }
+
+    template <typename... I> T &operator()(I... idxs) const
+    {
+        static_assert(sizeof...(idxs) == R,
+                      "[Class: DataView] Error in Catalyst Runtime: Wrong number of indices");
+        size_t indices[] = {static_cast<size_t>(idxs)...};
+
+        size_t loc = offset;
+        for (size_t axis = 0; axis < R; axis++) {
+            RT_ASSERT(indices[axis] < sizes[axis]);
+            loc += indices[axis] * strides[axis];
+        }
+        return data_aligned[loc];
+    }
+
+    iterator begin() { return iterator{*this, static_cast<int64_t>(offset)}; }
+
+    iterator end() { return iterator{*this, -1}; }
+};

pennylane_qrack-0.8.4/catalyst/runtime/include/Exception.hpp

@@ -0,0 +1,87 @@
+// Copyright 2023 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.
+
+#pragma once
+
+#include <exception>
+#include <iostream>
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+/**
+ * @brief Macro that throws `RuntimeException` with given message.
+ */
+#define RT_FAIL(message) Catalyst::Runtime::_abort((message), __FILE__, __LINE__, __func__)
+
+/**
+ * @brief Macro that throws `RuntimeException` if expression evaluates
+ * to true.
+ */
+#define RT_FAIL_IF(expression, message)                                                            \
+    if ((expression)) {                                                                            \
+        RT_FAIL(message);                                                                          \
+    }
+
+/**
+ * @brief Macro that throws `RuntimeException` with the given expression
+ * and source location if expression evaluates to false.
+ */
+#define RT_ASSERT(expression) RT_FAIL_IF(!(expression), "Assertion: " #expression)
+
+namespace Catalyst::Runtime {
+
+/**
+ * @brief This is the general exception thrown by Catalyst for runtime errors
+ * that is derived from `std::exception`.
+ */
+class RuntimeException : public std::exception {
+  private:
+    const std::string err_msg;
+
+  public:
+    explicit RuntimeException(std::string msg) noexcept
+        : err_msg{std::move(msg)} {}        // LCOV_EXCL_LINE
+    ~RuntimeException() override = default; // LCOV_EXCL_LINE
+
+    RuntimeException(const RuntimeException &) = default;
+    RuntimeException(RuntimeException &&) noexcept = default;
+
+    RuntimeException &operator=(const RuntimeException &) = delete;
+    RuntimeException &operator=(RuntimeException &&) = delete;
+
+    [[nodiscard]] auto what() const noexcept -> const char * override
+    {
+        return err_msg.c_str();
+    } // LCOV_EXCL_LINE
+};
+
+/**
+ * @brief Throws a `RuntimeException` with the given error message.
+ *
+ * @note This is not supposed to be called directly.
+ */
+[[noreturn]] inline void _abort(const char *message, const char *file_name, size_t line,
+                                const char *function_name)
+{
+    std::stringstream sstream;
+    sstream << "[" << file_name << "][Line:" << line << "][Function:" << function_name
+            << "] Error in Catalyst Runtime: " << message;
+
+    throw RuntimeException(sstream.str());
+} // LCOV_EXCL_LINE
+
+} // namespace Catalyst::Runtime

pennylane_qrack-0.8.4/catalyst/runtime/include/QuantumDevice.hpp

@@ -0,0 +1,319 @@
+// Copyright 2022-2023 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.
+
+#pragma once
+
+#include <complex>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "DataView.hpp"
+#include "Types.h"
+
+// A helper template macro to generate the <IDENTIFIER>Factory method by
+// calling <CONSTRUCTOR>(kwargs). Check the Custom Devices guideline for details:
+// https://docs.pennylane.ai/projects/catalyst/en/stable/dev/custom_devices.html
+#define GENERATE_DEVICE_FACTORY(IDENTIFIER, CONSTRUCTOR)                                           \
+    extern "C" Catalyst::Runtime::QuantumDevice *IDENTIFIER##Factory(const char *kwargs)           \
+    {                                                                                              \
+        return new CONSTRUCTOR(std::string(kwargs));                                               \
+    }
+
+namespace Catalyst::Runtime {
+
+/**
+ * @brief struct API for backend quantum devices.
+ *
+ * This device API contains,
+ * - a set of methods to manage qubit allocations and deallocations, device shot
+ *   noise, and quantum tape recording as well as reference values for the result
+ *   data-type; these are used to implement Quantum Runtime (QR) instructions.
+ *
+ * - a set of methods for quantum operations, observables, measurements, and gradient
+ *   of the device; these are used to implement Quantum Instruction Set (QIS) instructions.
+ *
+ */
+struct QuantumDevice {
+    QuantumDevice() = default;          // LCOV_EXCL_LINE
+    virtual ~QuantumDevice() = default; // LCOV_EXCL_LINE
+
+    QuantumDevice &operator=(const QuantumDevice &) = delete;
+    QuantumDevice(const QuantumDevice &) = delete;
+    QuantumDevice(QuantumDevice &&) = delete;
+    QuantumDevice &operator=(QuantumDevice &&) = delete;
+
+    /**
+     * @brief Allocate a qubit.
+     *
+     * @return `QubitIdType`
+     */
+    virtual auto AllocateQubit() -> QubitIdType = 0;
+
+    /**
+     * @brief Allocate a vector of qubits.
+     *
+     * @param num_qubits The number of qubits to allocate.
+     *
+     * @return `std::vector<QubitIdType>`
+     */
+    virtual auto AllocateQubits(size_t num_qubits) -> std::vector<QubitIdType> = 0;
+
+    /**
+     * @brief Release a qubit.
+     *
+     * @param qubit The id of the qubit
+     */
+    virtual void ReleaseQubit(QubitIdType qubit) = 0;
+
+    /**
+     * @brief Release all qubits.
+     */
+    virtual void ReleaseAllQubits() = 0;
+
+    /**
+     * @brief Get the number of allocated qubits.
+     *
+     * @return `size_t`
+     */
+    [[nodiscard]] virtual auto GetNumQubits() const -> size_t = 0;
+
+    /**
+     * @brief Set the number of device shots.
+     *
+     * @param shots The number of noise shots
+     */
+    virtual void SetDeviceShots(size_t shots) = 0;
+
+    /**
+     * @brief Get the number of device shots.
+     *
+     * @return `size_t`
+     */
+    [[nodiscard]] virtual auto GetDeviceShots() const -> size_t = 0;
+
+    /**
+     * @brief Start recording a quantum tape if provided.
+     *
+     * @note This is backed by the `Catalyst::Runtime::CacheManager<ComplexT>` property in
+     * the device implementation.
+     */
+    virtual void StartTapeRecording() = 0;
+
+    /**
+     * @brief Stop recording a quantum tape if provided.
+     *
+     * @note This is backed by the `Catalyst::Runtime::CacheManager<ComplexT>` property in
+     * the device implementation.
+     */
+    virtual void StopTapeRecording() = 0;
+
+    /**
+     * @brief Result value for "Zero" used in the measurement process.
+     *
+     * @return `Result`
+     */
+    [[nodiscard]] virtual auto Zero() const -> Result = 0;
+
+    /**
+     * @brief Result value for "One"  used in the measurement process.
+     *
+     * @return `Result`
+     */
+    [[nodiscard]] virtual auto One() const -> Result = 0;
+
+    /**
+     * @brief A helper method to print the state vector of a device.
+     */
+    virtual void PrintState() = 0;
+
+    /**
+     * @brief Apply a single gate to the state vector of a device with its name if this is
+     * supported.
+     *
+     * @param name The name of the gate to apply
+     * @param params Optional parameter list for parametric gates
+     * @param wires Wires to apply gate to
+     * @param inverse Indicates whether to use inverse of gate
+     * @param controlled_wires Optional controlled wires applied to the operation
+     * @param controlled_values Optional controlled values applied to the operation
+     */
+    virtual void
+    NamedOperation(const std::string &name, const std::vector<double> &params,
+                   const std::vector<QubitIdType> &wires, [[maybe_unused]] bool inverse = false,
+                   [[maybe_unused]] const std::vector<QubitIdType> &controlled_wires = {},
+                   [[maybe_unused]] const std::vector<bool> &controlled_values = {}) = 0;
+
+    /**
+     * @brief Apply a given matrix directly to the state vector of a device.
+     *
+     * @param matrix The matrix of data in row-major format
+     * @param wires Wires to apply gate to
+     * @param inverse Indicates whether to use inverse of gate
+     * @param controlled_wires Controlled wires applied to the operation
+     * @param controlled_values Controlled values applied to the operation
+     */
+    virtual void
+    MatrixOperation(const std::vector<std::complex<double>> &matrix,
+                    const std::vector<QubitIdType> &wires, [[maybe_unused]] bool inverse = false,
+                    [[maybe_unused]] const std::vector<QubitIdType> &controlled_wires = {},
+                    [[maybe_unused]] const std::vector<bool> &controlled_values = {}) = 0;
+
+    /**
+     * @brief Construct a named (Identity, PauliX, PauliY, PauliZ, and Hadamard)
+     * or Hermitian observable.
+     *
+     * @param id The type of the observable
+     * @param matrix The matrix of data to construct a hermitian observable
+     * @param wires Wires to apply observable to
+     *
+     * @return `ObsIdType` Index of the constructed observable
+     */
+    virtual auto Observable(ObsId id, const std::vector<std::complex<double>> &matrix,
+                            const std::vector<QubitIdType> &wires) -> ObsIdType = 0;
+
+    /**
+     * @brief Construct a tensor product of observables.
+     *
+     * @param obs The vector of observables indices of type ObsIdType
+     *
+     * @return `ObsIdType` Index of the constructed observable
+     */
+    virtual auto TensorObservable(const std::vector<ObsIdType> &obs) -> ObsIdType = 0;
+
+    /**
+     * @brief Construct a Hamiltonian observable.
+     *
+     * @param coeffs The vector of coefficients
+     * @param obs The vector of observables indices of size `coeffs`
+     *
+     * @return `ObsIdType` Index of the constructed observable
+     */
+    virtual auto HamiltonianObservable(const std::vector<double> &coeffs,
+                                       const std::vector<ObsIdType> &obs) -> ObsIdType = 0;
+
+    /**
+     * @brief Compute the expected value of an observable.
+     *
+     * @param obsKey The index of the constructed observable
+     *
+     * @return `double` The expected value
+     */
+    virtual auto Expval(ObsIdType obsKey) -> double = 0;
+
+    /**
+     * @brief Compute the variance of an observable.
+     *
+     * @param obsKey The index of the constructed observable
+     *
+     * @return `double` The variance
+     */
+    virtual auto Var(ObsIdType obsKey) -> double = 0;
+
+    /**
+     * @brief Get the state-vector of a device.
+     *
+     * @param state The pre-allocated `DataView<complex<double>, 1>`
+     */
+    virtual void State(DataView<std::complex<double>, 1> &state) = 0;
+
+    /**
+     * @brief Compute the probabilities of each computational basis state.
+
+     * @param probs The pre-allocated `DataView<double, 1>`
+     */
+    virtual void Probs(DataView<double, 1> &probs) = 0;
+
+    /**
+     * @brief Compute the probabilities for a subset of the full system.
+     *
+     * @param probs The pre-allocated `DataView<double, 1>`
+     * @param wires Wires will restrict probabilities to a subset of the full system
+     */
+    virtual void PartialProbs(DataView<double, 1> &probs,
+                              const std::vector<QubitIdType> &wires) = 0;
+
+    /**
+     * @brief Compute samples with the number of shots on the entire wires,
+     * returing raw samples.
+     *
+     * @param samples The pre-allocated `DataView<double, 2>`representing a matrix of
+     * shape `shots * numQubits`. The built-in iterator in `DataView<double, 2>`
+     * iterates over all elements of `samples` row-wise.
+     * @param shots The number of shots
+     */
+    virtual void Sample(DataView<double, 2> &samples, size_t shots) = 0;
+
+    /**
+     * @brief Compute partial samples with the number of shots on `wires`,
+     * returing raw samples.
+     *
+     * @param samples The pre-allocated `DataView<double, 2>`representing a matrix of
+     * shape `shots * numWires`. The built-in iterator in `DataView<double, 2>`
+     * iterates over all elements of `samples` row-wise.
+     * @param wires Wires to compute samples on
+     * @param shots The number of shots
+     */
+    virtual void PartialSample(DataView<double, 2> &samples, const std::vector<QubitIdType> &wires,
+                               size_t shots) = 0;
+
+    /**
+     * @brief Sample with the number of shots on the entire wires, returning the
+     * number of counts for each sample.
+     *
+     * @param eigvals The pre-allocated `DataView<double, 1>`
+     * @param counts The pre-allocated `DataView<int64_t, 1>`
+     * @param shots The number of shots
+     */
+    virtual void Counts(DataView<double, 1> &eigvals, DataView<int64_t, 1> &counts,
+                        size_t shots) = 0;
+
+    /**
+     * @brief Partial sample with the number of shots on `wires`, returning the
+     * number of counts for each sample.
+     *
+     * @param eigvals The pre-allocated `DataView<double, 1>`
+     * @param counts The pre-allocated `DataView<int64_t, 1>`
+     * @param wires Wires to compute samples on
+     * @param shots The number of shots
+     */
+    virtual void PartialCounts(DataView<double, 1> &eigvals, DataView<int64_t, 1> &counts,
+                               const std::vector<QubitIdType> &wires, size_t shots) = 0;
+
+    /**
+     * @brief A general measurement method that acts on a single wire.
+     *
+     * @param wire The wire to compute Measure on
+     * @param postselect Which basis state to postselect after a mid-circuit measurement (-1 denotes
+     no post-selection)
+
+     * @return `Result` The measurement result
+     */
+    virtual auto Measure(QubitIdType wire, std::optional<int32_t> postselect) -> Result = 0;
+
+    /**
+     * @brief Compute the gradient of a quantum tape, that is cached using
+     * `Catalyst::Runtime::Simulator::CacheManager`, for a specific set of trainable
+     * parameters.
+     *
+     * @param gradients The vector of pre-allocated `DataView<double, 1>*`
+     * to store gradients resutls for the list of cached observables.
+     * @param trainParams The vector of trainable parameters; if none, all parameters
+     * would be assumed trainable
+     *
+     */
+    virtual void Gradient(std::vector<DataView<double, 1>> &gradients,
+                          const std::vector<size_t> &trainParams) = 0;
+};
+} // namespace Catalyst::Runtime

pennylane_qrack-0.8.4/catalyst/runtime/include/RuntimeCAPI.h

@@ -0,0 +1,109 @@
+// Copyright 2022-2023 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.
+
+#pragma once
+#ifndef RUNTIMECAPI_H
+#define RUNTIMECAPI_H
+
+#include "Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Quantum Runtime Instructions
+void __catalyst__rt__fail_cstr(const char *);
+void __catalyst__rt__initialize();
+void __catalyst__rt__device_init(int8_t *, int8_t *, int8_t *);
+void __catalyst__rt__device_release();
+void __catalyst__rt__finalize();
+void __catalyst__rt__toggle_recorder(bool);
+void __catalyst__rt__print_state();
+void __catalyst__rt__print_tensor(OpaqueMemRefT *, bool);
+void __catalyst__rt__print_string(char *);
+int64_t __catalyst__rt__array_get_size_1d(QirArray *);
+int8_t *__catalyst__rt__array_get_element_ptr_1d(QirArray *, int64_t);
+
+QUBIT *__catalyst__rt__qubit_allocate();
+QirArray *__catalyst__rt__qubit_allocate_array(int64_t);
+void __catalyst__rt__qubit_release(QUBIT *);
+void __catalyst__rt__qubit_release_array(QirArray *);
+
+int64_t __catalyst__rt__num_qubits();
+
+bool __catalyst__rt__result_equal(RESULT *, RESULT *);
+RESULT *__catalyst__rt__result_get_one();
+RESULT *__catalyst__rt__result_get_zero();
+
+// Quantum Gate Set Instructions
+void __catalyst__qis__Identity(QUBIT *, const Modifiers *);
+void __catalyst__qis__PauliX(QUBIT *, const Modifiers *);
+void __catalyst__qis__PauliY(QUBIT *, const Modifiers *);
+void __catalyst__qis__PauliZ(QUBIT *, const Modifiers *);
+void __catalyst__qis__Hadamard(QUBIT *, const Modifiers *);
+void __catalyst__qis__S(QUBIT *, const Modifiers *);
+void __catalyst__qis__T(QUBIT *, const Modifiers *);
+void __catalyst__qis__PhaseShift(double, QUBIT *, const Modifiers *);
+void __catalyst__qis__RX(double, QUBIT *, const Modifiers *);
+void __catalyst__qis__RY(double, QUBIT *, const Modifiers *);
+void __catalyst__qis__RZ(double, QUBIT *, const Modifiers *);
+void __catalyst__qis__Rot(double, double, double, QUBIT *, const Modifiers *);
+void __catalyst__qis__CNOT(QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CY(QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CZ(QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__SWAP(QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__IsingXX(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__IsingYY(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__IsingXY(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__IsingZZ(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__ControlledPhaseShift(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CRX(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CRY(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CRZ(double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CRot(double, double, double, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__CSWAP(QUBIT *, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__Toffoli(QUBIT *, QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__MultiRZ(double, const Modifiers *, int64_t, /*qubits*/...);
+void __catalyst__qis__GlobalPhase(double, const Modifiers *);
+void __catalyst__qis__ISWAP(QUBIT *, QUBIT *, const Modifiers *);
+void __catalyst__qis__PSWAP(double, QUBIT *, QUBIT *, const Modifiers *);
+
+// Struct pointer arguments for these instructions represent real arguments,
+// as passing structs by value is too unreliable / compiler dependant.
+void __catalyst__qis__QubitUnitary(MemRefT_CplxT_double_2d *, const Modifiers *, int64_t,
+                                   /*qubits*/...);
+
+ObsIdType __catalyst__qis__NamedObs(int64_t, QUBIT *);
+ObsIdType __catalyst__qis__HermitianObs(MemRefT_CplxT_double_2d *, int64_t, /*qubits*/...);
+ObsIdType __catalyst__qis__TensorObs(int64_t, /*obsKeys*/...);
+ObsIdType __catalyst__qis__HamiltonianObs(MemRefT_double_1d *, int64_t, /*obsKeys*/...);
+
+// Struct pointers arguments here represent return values.
+RESULT *__catalyst__qis__Measure(QUBIT *, int32_t);
+double __catalyst__qis__Expval(ObsIdType);
+double __catalyst__qis__Variance(ObsIdType);
+void __catalyst__qis__Probs(MemRefT_double_1d *, int64_t, /*qubits*/...);
+void __catalyst__qis__Sample(MemRefT_double_2d *, int64_t, int64_t, /*qubits*/...);
+void __catalyst__qis__Counts(PairT_MemRefT_double_int64_1d *, int64_t, int64_t, /*qubits*/...);
+void __catalyst__qis__State(MemRefT_CplxT_double_1d *, int64_t, /*qubits*/...);
+void __catalyst__qis__Gradient(int64_t, /*results*/...);
+void __catalyst__qis__Gradient_params(MemRefT_int64_1d *, int64_t, /*results*/...);
+
+void __catalyst__host__rt__unrecoverable_error();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

pennylane_qrack-0.8.4/catalyst/runtime/include/Types.h

@@ -0,0 +1,156 @@
+// Copyright 2022-2023 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.
+
+#pragma once
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Qubit, Result and Observable types
+struct QUBIT;
+typedef intptr_t QubitIdType;
+
+typedef bool RESULT;
+typedef RESULT *Result;
+typedef void *QirArray;
+
+typedef intptr_t ObsIdType;
+
+enum ObsId : int8_t {
+    Identity = 0,
+    PauliX,
+    PauliY,
+    PauliZ,
+    Hadamard,
+    Hermitian,
+};
+
+enum ObsType : int8_t {
+    Basic = 0,
+    TensorProd,
+    Hamiltonian,
+};
+
+// complex<float> type
+struct CplxT_float {
+    float real;
+    float imag;
+};
+
+// complex<double> type
+struct CplxT_double {
+    double real;
+    double imag;
+};
+
+enum NumericType : int8_t {
+    idx = 0,
+    i1,
+    i8,
+    i16,
+    i32,
+    i64,
+    f32,
+    f64,
+    c64,
+    c128,
+};
+
+// MemRefT<datatype, dimension=rank> type
+struct OpaqueMemRefT {
+    int64_t rank;
+    void *descriptor;
+    NumericType datatype;
+};
+
+// MemRefT<complex<double>, dimension=1> type
+struct MemRefT_CplxT_double_1d {
+    CplxT_double *data_allocated;
+    CplxT_double *data_aligned;
+    size_t offset;
+    size_t sizes[1];
+    size_t strides[1];
+};
+
+// MemRefT<complex<double>, dimension=2> type
+struct MemRefT_CplxT_double_2d {
+    CplxT_double *data_allocated;
+    CplxT_double *data_aligned;
+    size_t offset;
+    size_t sizes[2];
+    size_t strides[2];
+};
+
+// MemRefT<double, dimension=1> type
+struct MemRefT_double_1d {
+    double *data_allocated;
+    double *data_aligned;
+    size_t offset;
+    size_t sizes[1];
+    size_t strides[1];
+};
+
+// MemRefT<double, dimension=2> type
+struct MemRefT_double_2d {
+    double *data_allocated;
+    double *data_aligned;
+    size_t offset;
+    size_t sizes[2];
+    size_t strides[2];
+};
+
+// MemRefT<int64_t, dimension=1> type
+struct MemRefT_int64_1d {
+    int64_t *data_allocated;
+    int64_t *data_aligned;
+    size_t offset;
+    size_t sizes[1];
+    size_t strides[1];
+};
+
+// PairT<MemRefT<double, dimension=1>, MemRefT<int64, dimension=2>> type
+struct PairT_MemRefT_double_int64_1d {
+    struct MemRefT_double_1d first;
+    struct MemRefT_int64_1d second;
+};
+
+// Quantum operation modifiers
+struct Modifiers {
+    bool adjoint;
+    size_t num_controlled;
+    QUBIT *controlled_wires;
+    bool *controlled_values;
+};
+
+typedef struct CplxT_double CplxT_double;
+typedef struct MemRefT_CplxT_double_1d MemRefT_CplxT_double_1d;
+typedef struct MemRefT_CplxT_double_2d MemRefT_CplxT_double_2d;
+typedef struct MemRefT_double_1d MemRefT_double_1d;
+typedef struct MemRefT_double_2d MemRefT_double_2d;
+typedef struct MemRefT_int64_1d MemRefT_int64_1d;
+typedef struct PairT_MemRefT_double_int64_1d PairT_MemRefT_double_int64_1d;
+typedef struct Modifiers Modifiers;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4}/pennylane_qrack/QrackDeviceConfig.toml

@@ -102,9 +102,9 @@ Prod = {}
 
 [measurement_processes]
 
-Expval = {}
-Var = {}
-Probs = {}
+Expval = { condition = [ "analytic" ] }
+Var = { condition = [ "analytic" ] }
+Probs = { condition = [ "analytic" ] }
 State  = { condition = [ "analytic" ] }
 Sample = { condition = [ "finiteshots" ] }
 Counts = { condition = [ "finiteshots" ] }
@@ -128,10 +128,6 @@ dynamic_qubit_management = true
 # The option key will be the key in a dictionary.
 # The string corresponds to a field queried in the `qml.Device` instance.
 
-# Number of qubit wires
-wires = "wires"
-# Number of shots per job
-shots = "shots"
 # Use "hybrid" stabilizer optimization? (Default is "true"; non-Clifford circuits will fall back to near-Clifford or universal simulation)
 is_hybrid_stabilizer = "isStabilizerHybrid"
 # Use "tensor network" optimization? (Default is "true"; prevents dynamic qubit de-allocation; might function sub-optimally with "hybrid" stabilizer enabled)

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4}/pennylane_qrack/_version.py

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

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4}/pennylane_qrack/qrack_device.cpp

@@ -40,8 +40,6 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
     bool oc;
     bool hp;
     bool nw;
-    bitLenInt allocated_qubits;
-    bitLenInt mapped_qubits;
     size_t shots;
     Qrack::QInterfacePtr qsim;
     std::map<QubitIdType, bitLenInt> qubit_map;
@@ -391,8 +389,6 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         , oc(true)
         , hp(false)
         , nw(false)
-        , allocated_qubits(0U)
-        , mapped_qubits(0U)
         , shots(1U)
         , qsim(nullptr)
     {
@@ -403,98 +399,46 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         kwargs = trim(kwargs);
 
         std::map<std::string, int> keyMap;
-        keyMap["'wires'"] = 1;
-        keyMap["'shots'"] = 2;
-        keyMap["'is_hybrid_stabilizer'"] = 3;
-        keyMap["'is_tensor_network'"] = 4;
-        keyMap["'is_schmidt_decomposed'"] = 5;
-        keyMap["'is_schmidt_decomposition_parallel'"] = 6;
-        keyMap["'is_qbdd'"] = 7;
-        keyMap["'is_gpu'"] = 8;
-        keyMap["'is_host_pointer'"] = 9;
-        keyMap["'is_noisy'"] = 10;
+        keyMap["'is_hybrid_stabilizer'"] = 1;
+        keyMap["'is_tensor_network'"] = 2;
+        keyMap["'is_schmidt_decomposed'"] = 3;
+        keyMap["'is_schmidt_decomposition_parallel'"] = 4;
+        keyMap["'is_qbdd'"] = 5;
+        keyMap["'is_gpu'"] = 6;
+        keyMap["'is_host_pointer'"] =7;
+        keyMap["'is_noisy'"] = 8;
 
         size_t pos;
         while ((pos = kwargs.find(":")) != std::string::npos) {
             std::string key = trim(kwargs.substr(0, pos));
             kwargs.erase(0, pos + 1U);
-
-            if (key == "'wires'") {
-                // Handle if empty
-                // We look for ',' or npos, to respect other Wires value kwargs
-                if (kwargs.find("<Wires = []>") != kwargs.find("<Wires = []>,")) {
-                    continue;
-                }
-
-                // Handle if integer
-                pos = kwargs.find(",");
-                bool isInt = true;
-                for (size_t i = 0; i < pos; ++i) {
-                    if ((kwargs[i] != ' ') && !isdigit(kwargs[i])) {
-                        isInt = false;
-                        break;
-                    }
-                }
-                if (isInt) {
-                    mapped_qubits = stoi(trim(kwargs.substr(0, pos)));
-                    for (size_t i = 0U; i < mapped_qubits; ++i) {
-                        qubit_map[i] = i;
-                    }
-                    kwargs.erase(0, pos + 1U);
-
-                    continue;
-                }
-
-                // Handles if Wires object
-                pos = kwargs.find("]>");
-                std::string value = kwargs.substr(0, pos);
-                kwargs.erase(0, pos + 3U);
-                size_t p = value.find("[");
-                value.erase(0, p + 1U);
-                size_t q;
-                while ((q = value.find(",")) != std::string::npos) {
-                    qubit_map[(QubitIdType)stoi(trim(value.substr(0, q)))] = mapped_qubits;
-                    ++mapped_qubits;
-                    value.erase(0, q + 1U);
-                }
-                qubit_map[stoi(trim(value))] = mapped_qubits;
-                ++mapped_qubits;
-
-                continue;
-            }
-
             pos = kwargs.find(",");
             std::string value = trim(kwargs.substr(0, pos));
             kwargs.erase(0, pos + 1U);
             const bool val = (value == "True");
             switch (keyMap[key]) {
-                case 2:
-                    if (value != "None") {
-                        shots = std::stoi(value);
-                    }
-                    break;
-                case 3:
+                case 1:
                     sh = val;
                     break;
-                case 4:
+                case 2:
                     tn = val;
                     break;
-                case 5:
+                case 3:
                     sd = val;
                     break;
-                case 6:
+                case 4:
                     md = val;
                     break;
-                case 7:
+                case 5:
                     bdt = val;
                     break;
-                case 8:
+                case 6:
                     oc =  val;
                     break;
-                case 9:
+                case 7:
                     hp = val;
                     break;
-                case 10:
+                case 8:
                     nw = val;
                     break;
                 default:
@@ -511,16 +455,8 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
     QrackDevice &operator=(QuantumDevice &&) = delete;
 
     auto AllocateQubit() -> QubitIdType override {
-        if (allocated_qubits >= qubit_map.size()) {
-            throw std::runtime_error("Catalyst has requested more qubits than exist in device, with "
-                + std::to_string(allocated_qubits) + " allocated qubits. "
-                + "(Set your wires count high enough, for the device.)");
-        }
+        const QubitIdType label = qsim->GetQubitCount();
         qsim->Allocate(1U);
-        auto it = qubit_map.begin();
-        std::advance(it, allocated_qubits);
-        const QubitIdType label = it->first;
-        ++allocated_qubits;
         return label;
     }
     auto AllocateQubits(size_t num_qubits) -> std::vector<QubitIdType> override {
@@ -590,13 +526,11 @@ struct QrackDevice final : public Catalyst::Runtime::QuantumDevice {
         qsim->M(id);
         // Deallocate
         qsim->Dispose(id, 1U);
-        --allocated_qubits;
     }
     void ReleaseAllQubits() override
     {
         // State vector is left empty
         qsim = QSIM_CONFIG(0U);
-        allocated_qubits = 0;
     }
     [[nodiscard]] auto GetNumQubits() const -> size_t override
     {

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4/pennylane_qrack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pennylane-qrack
-Version: 0.8.1
+Version: 0.8.4
 Summary: PennyLane plugin for Qrack.
 Home-page: http://github.com/vm6502q
 Maintainer: vm6502q

{pennylane_qrack-0.8.1 → pennylane_qrack-0.8.4}/pennylane_qrack.egg-info/SOURCES.txt

@@ -6,9 +6,15 @@ Makefile
 README.rst
 requirements.txt
 setup.py
+catalyst/runtime/include/DataView.hpp
+catalyst/runtime/include/Exception.hpp
+catalyst/runtime/include/QuantumDevice.hpp
+catalyst/runtime/include/RuntimeCAPI.h
+catalyst/runtime/include/Types.h
 pennylane_qrack/QrackDeviceConfig.toml
 pennylane_qrack/__init__.py
 pennylane_qrack/_version.py
+pennylane_qrack/libqrack_device.so
 pennylane_qrack/qrack_device.cpp
 pennylane_qrack/qrack_device.py
 pennylane_qrack.egg-info/PKG-INFO