pyqrack-complex128 1.78.3__py3-none-macosx_14_0_arm64.whl → 1.80.2__py3-none-macosx_14_0_arm64.whl

pyqrack/__init__.py

@@ -13,7 +13,6 @@ from .qrack_neuron_torch_layer import (
     QrackNeuronTorch,
     QrackNeuronTorchFunction,
     QrackNeuronTorchLayer,
-    QrackNeuronTorchLayerFunction,
 )
 from .qrack_simulator import QrackSimulator
 from .qrack_stabilizer import QrackStabilizer

pyqrack/qrack_ace_backend.py

@@ -224,9 +224,7 @@ class QrackAceBackend:
         isPaged=True,
         isCpuGpuHybrid=True,
         isOpenCL=True,
-        isHostPointer=(
-            True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False
-        ),
+        isHostPointer=(True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False),
         noise=0,
         toClone=None,
     ):
@@ -294,11 +292,7 @@ class QrackAceBackend:
                     sim_counts[t_sim_id] += 1
 
                     qubit.append(
-                        LHVQubit(
-                            toClone=(
-                                toClone._qubits[tot_qubits][2] if toClone else None
-                            )
-                        )
+                        LHVQubit(toClone=(toClone._qubits[tot_qubits][2] if toClone else None))
                     )
 
                 if (not c) and (not r):
@@ -545,9 +539,7 @@ class QrackAceBackend:
                 self.sim[hq[4][0]].prob(hq[4][1]),
             ]
             # Balancing suggestion from Elara (the custom OpenAI GPT)
-            prms = math.sqrt(
-                (p[0] ** 2 + p[1] ** 2 + 3 * (p[2] ** 2) + p[3] ** 2 + p[4] ** 2) / 7
-            )
+            prms = math.sqrt((p[0] ** 2 + p[1] ** 2 + 3 * (p[2] ** 2) + p[3] ** 2 + p[4] ** 2) / 7)
             qrms = math.sqrt(
                 (
                     (1 - p[0]) ** 2
@@ -860,9 +852,7 @@ class QrackAceBackend:
             gate = self.sim[sim_id].macz if anti else self.sim[sim_id].mcz
             shadow = self._anti_cz_shadow if anti else self._cz_shadow
         else:
-            raise RuntimeError(
-                "QrackAceBackend._get_gate() should never return identity!"
-            )
+            raise RuntimeError("QrackAceBackend._get_gate() should never return identity!")
 
         return gate, shadow
 
@@ -899,11 +889,7 @@ class QrackAceBackend:
                 b2 = hq2[q2]
                 if b1[0] == b2[0]:
                     gate_fn([b1[1]], b2[1])
-                elif (
-                    lq1_lr
-                    or (b1[1] == b2[1])
-                    or ((len(qb1) == 2) and (b1[1] == (b2[1] & 1)))
-                ):
+                elif lq1_lr or (b1[1] == b2[1]) or ((len(qb1) == 2) and (b1[1] == (b2[1] & 1))):
                     shadow_fn(b1, b2)
 
     def _cpauli(self, lq1, lq2, anti, pauli):
@@ -1033,9 +1019,7 @@ class QrackAceBackend:
                 self.sim[hq[4][0]].prob(hq[4][1]),
             ]
             # Balancing suggestion from Elara (the custom OpenAI GPT)
-            prms = math.sqrt(
-                (p[0] ** 2 + p[1] ** 2 + 3 * (p[2] ** 2) + p[3] ** 2 + p[4] ** 2) / 7
-            )
+            prms = math.sqrt((p[0] ** 2 + p[1] ** 2 + 3 * (p[2] ** 2) + p[3] ** 2 + p[4] ** 2) / 7)
             qrms = math.sqrt(
                 (
                     (1 - p[0]) ** 2
@@ -1187,17 +1171,11 @@ class QrackAceBackend:
                 (-1 * float(operation.params[1])) + math.pi / 2,
             )
         elif name == "rx":
-            self._sim.r(
-                Pauli.PauliX, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliX, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "ry":
-            self._sim.r(
-                Pauli.PauliY, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliY, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "rz":
-            self._sim.r(
-                Pauli.PauliZ, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliZ, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "h":
             self._sim.h(operation.qubits[0]._index)
         elif name == "x":
@@ -1262,9 +1240,9 @@ class QrackAceBackend:
                         cregbit = clbit
 
                     regbit = 1 << cregbit
-                    self._classical_register = (
-                        self._classical_register & (~regbit)
-                    ) | (qubit_outcome << cregbit)
+                    self._classical_register = (self._classical_register & (~regbit)) | (
+                        qubit_outcome << cregbit
+                    )
 
         elif name == "bfunc":
             mask = int(operation.mask, 16)
@@ -1379,9 +1357,7 @@ class QrackAceBackend:
             if operation.name == "id" or operation.name == "barrier":
                 continue
 
-            if is_initializing and (
-                (operation.name == "measure") or (operation.name == "reset")
-            ):
+            if is_initializing and ((operation.name == "measure") or (operation.name == "reset")):
                 continue
 
             is_initializing = False
@@ -1439,9 +1415,7 @@ class QrackAceBackend:
                 self._sample_cregbits = []
 
         if self._sample_measure and (len(self._sample_qubits) > 0):
-            _data = self._add_sample_measure(
-                self._sample_qubits, self._sample_clbits, self._shots
-            )
+            _data = self._add_sample_measure(self._sample_qubits, self._sample_clbits, self._shots)
 
         del self._sim
 
@@ -1532,17 +1506,13 @@ class QrackAceBackend:
                 noise_model.add_quantum_error(depolarizing_error(y, 2), "cx", [a, b])
                 noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cy", [a, b])
                 noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cz", [a, b])
-                noise_model.add_quantum_error(
-                    depolarizing_error(y_swap, 2), "swap", [a, b]
-                )
+                noise_model.add_quantum_error(depolarizing_error(y_swap, 2), "swap", [a, b])
             else:
                 y_cy = 1 - (1 - y) ** 2
                 y_swap = 1 - (1 - y) ** 3
                 noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cx", [a, b])
                 noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cy", [a, b])
                 noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cz", [a, b])
-                noise_model.add_quantum_error(
-                    depolarizing_error(y_swap, 2), "swap", [a, b]
-                )
+                noise_model.add_quantum_error(depolarizing_error(y_swap, 2), "swap", [a, b])
 
         return noise_model

pyqrack/qrack_circuit.py

@@ -507,9 +507,7 @@ class QrackCircuit:
             )
             if circuit_type == QuimbCircuitType.Circuit
             else (
-                qtn.CircuitDense(
-                    N=qcirc.num_qubits, psi0=psi0, gate_opts=gate_opts, tags=tags
-                )
+                qtn.CircuitDense(N=qcirc.num_qubits, psi0=psi0, gate_opts=gate_opts, tags=tags)
                 if circuit_type == QuimbCircuitType.CircuitDense
                 else qtn.CircuitMPS(
                     N=qcirc.num_qubits,
@@ -540,9 +538,7 @@ class QrackCircuit:
         return tcirc
 
     @staticmethod
-    def file_to_tensorcircuit(
-        filename, inputs=None, circuit_params=None, binding_params=None
-    ):
+    def file_to_tensorcircuit(filename, inputs=None, circuit_params=None, binding_params=None):
         """Convert an output file to a TensorCircuit circuit
 
         Reads in an (optimized) circuit from a file named

pyqrack/qrack_neuron.py

@@ -110,6 +110,21 @@ class QrackNeuron:
             return (ctypes.c_float * len(a))(*a)
         return (ctypes.c_double * len(a))(*a)
 
+    def set_simulator(self, s):
+        """Set the neuron simulator
+
+        Set the simulator used by this neuron
+
+        Args:
+            s(QrackSimulator): The simulator to use
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+        """
+        Qrack.qrack_lib.set_qneuron_sim(self.nid, s.sid)
+        self._throw_if_error()
+        self.simulator = s
+
     def set_angles(self, a):
         """Directly sets the neuron parameters.
 
@@ -265,7 +280,7 @@ class QrackNeuron:
 
     @staticmethod
     def quantile_bounds(vec, bits):
-        """ Calculate vector quantile bounds
+        """Calculate vector quantile bounds
 
         This is a static helper method to calculate the quantile
         bounds of 2 ** bits worth of quantiles.
@@ -283,11 +298,15 @@ class QrackNeuron:
         n = len(vec)
         vec_sorted = sorted(vec)
 
-        return [vec_sorted[0]] + [vec_sorted[(k * n) // bins] for k in range(1, bins)] + [vec_sorted[-1]]
+        return (
+            [vec_sorted[0]]
+            + [vec_sorted[(k * n) // bins] for k in range(1, bins)]
+            + [vec_sorted[-1]]
+        )
 
     @staticmethod
     def discretize(vec, bounds):
-        """ Discretize vector by quantile bounds
+        """Discretize vector by quantile bounds
 
         This is a static helper method to discretize a numerical
         vector according to quantile bounds calculated by the
@@ -317,7 +336,7 @@ class QrackNeuron:
 
     @staticmethod
     def flatten_and_transpose(arr):
-        """ Flatten and transpose feature matrix
+        """Flatten and transpose feature matrix
 
         This is a static helper method to convert a multi-feature
         bit-row matrix to an observation-row matrix with flat
@@ -333,7 +352,7 @@ class QrackNeuron:
 
     @staticmethod
     def bin_endpoints_average(bounds):
-        """ Bin endpoints average
+        """Bin endpoints average
 
         This is a static helper method that accepts the output
         bins from quantile_bounds() and returns the average points

pyqrack/qrack_neuron_torch_layer.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
 #
 # Initial draft by Elara (OpenAI custom GPT)
 # Refined and architecturally clarified by Dan Strano
@@ -8,6 +8,7 @@
 
 import itertools
 import math
+import random
 import sys
 
 _IS_TORCH_AVAILABLE = True
@@ -24,99 +25,84 @@ from .qrack_simulator import QrackSimulator
 from .neuron_activation_fn import NeuronActivationFn
 
 
-# Should be safe for 16-bit
-angle_eps = math.pi * (2 ** -8)
+# Parameter-shift rule
+param_shift_eps = math.pi / 2
+# Neuron angle initialization
+init_phi = math.asin(0.5)
 
 
-if not _IS_TORCH_AVAILABLE:
-    class TorchContextMock(object):
-        def __init__(self):
-            pass
-
-        def save_for_backward(self, *args):
-            self.saved_tensors = args
-
 class QrackNeuronTorchFunction(Function if _IS_TORCH_AVAILABLE else object):
     """Static forward/backward/apply functions for QrackNeuronTorch"""
 
-    if not _IS_TORCH_AVAILABLE:
-        @staticmethod
-        def apply(x, neuron_wrapper):
-            return forward(TorchContextMock(), x, neuron_wrapper)
-
     @staticmethod
-    def forward(ctx, x, neuron_wrapper):
-        ctx.neuron_wrapper = neuron_wrapper
+    def forward(ctx, x, neuron):
+        ctx.neuron = neuron
+        ctx.simulator = neuron.simulator
         ctx.save_for_backward(x)
-        neuron = neuron_wrapper.neuron
 
-        angles = (x.detach().cpu().numpy() if x.requires_grad else x.numpy()) if _IS_TORCH_AVAILABLE else x
+        # Baseline probability BEFORE applying this neuron's unitary
+        pre_prob = neuron.simulator.prob(neuron.target)
+
+        angles = x.detach().cpu().numpy() if x.requires_grad else x.numpy()
         neuron.set_angles(angles)
         neuron.predict(True, False)
+
+        # Probability AFTER applying this neuron's unitary
         post_prob = neuron.simulator.prob(neuron.target)
-        if _IS_TORCH_AVAILABLE:
-            post_prob = torch.tensor([post_prob], dtype=torch.float32, device=x.device)
+        ctx.post_prob = post_prob
+
+        delta = math.asin(post_prob) - math.asin(pre_prob)
+        ctx.delta = delta
 
-        return post_prob
+        # Return shape: (1,)
+        return x.new_tensor([delta])
 
     @staticmethod
-    def _backward(x, neuron_wrapper):
-        neuron = neuron_wrapper.neuron
-        angles = (x.detach().cpu().numpy() if x.requires_grad else x.numpy()) if _IS_TORCH_AVAILABLE else x
+    def backward(ctx, grad_output):
+        (x,) = ctx.saved_tensors
+        neuron = ctx.neuron
+        neuron.set_simulator(ctx.simulator)
+        post_prob = ctx.post_prob
+
+        angles = x.detach().cpu().numpy() if x.requires_grad else x.numpy()
 
-        # Uncompute
+        # Restore simulator to state BEFORE this neuron's unitary
         neuron.set_angles(angles)
         neuron.unpredict()
         pre_sim = neuron.simulator
-        pre_prob = pre_sim.prob(neuron.target)
 
-        param_count = 1 << len(neuron.controls)
-        delta = [0.0] * param_count
-        for param in range(param_count):
-            angle = angles[param]
+        grad_x = torch.zeros_like(x)
 
-            # x + angle_eps
-            angles[param] = angle + angle_eps
+        for i in range(x.shape[0]):
+            angle = angles[i]
+
+            # θ + π/2
+            angles[i] = angle + param_shift_eps
             neuron.set_angles(angles)
             neuron.simulator = pre_sim.clone()
             neuron.predict(True, False)
             p_plus = neuron.simulator.prob(neuron.target)
 
-            # x - angle_eps
-            angles[param] = angle - angle_eps
+            # θ − π/2
+            angles[i] = angle - param_shift_eps
             neuron.set_angles(angles)
             neuron.simulator = pre_sim.clone()
             neuron.predict(True, False)
             p_minus = neuron.simulator.prob(neuron.target)
 
-            # Central difference
-            delta[param] = (p_plus - p_minus) / (2 * angle_eps)
+            # Parameter-shift gradient
+            grad_x[i] = 0.5 * (p_plus - p_minus)
 
-            angles[param] = angle
+            angles[i] = angle
 
-        neuron.simulator = pre_sim
+        # Restore simulator
+        neuron.set_simulator(pre_sim)
 
-        if _IS_TORCH_AVAILABLE:
-            delta = torch.tensor(delta, dtype=torch.float32, device=x.device)
+        # Apply chain rule and upstream gradient
+        grad_x *= grad_output[0] / math.sqrt(max(1.0 - post_prob * post_prob, 1e-6))
 
-        return delta
+        return grad_x, None
 
-    @staticmethod
-    def backward(ctx, grad_output):
-        (x,) = ctx.saved_tensors
-        neuron_wrapper = ctx.neuron_wrapper
-        delta = _backward(x, neuron_wrapper, grad_output)
-        if _IS_TORCH_AVAILABLE:
-            # grad_output: (O,)
-            # delta:       (O, I)
-            grad_input = torch.matmul(grad_output, delta)  # result: (I,)
-        else:
-            grad_input = [
-                sum(o * d for o, d in zip(grad_output, col))
-                for col in zip(*delta)
-            ]
-
-        return grad_input, None
 
 class QrackNeuronTorch(nn.Module if _IS_TORCH_AVAILABLE else object):
     """Torch wrapper for QrackNeuron
@@ -125,12 +111,13 @@ class QrackNeuronTorch(nn.Module if _IS_TORCH_AVAILABLE else object):
         neuron(QrackNeuron): QrackNeuron backing this torch wrapper
     """
 
-    def __init__(self, neuron):
+    def __init__(self, neuron, x):
         super().__init__()
         self.neuron = neuron
+        self.weights = nn.Parameter(x)
 
-    def forward(self, x):
-        return QrackNeuronTorchFunction.apply(x, self.neuron)
+    def forward(self):
+        return QrackNeuronTorchFunction.apply(self.weights, self.neuron)
 
 
 class QrackNeuronTorchLayer(nn.Module if _IS_TORCH_AVAILABLE else object):
@@ -156,7 +143,9 @@ class QrackNeuronTorchLayer(nn.Module if _IS_TORCH_AVAILABLE else object):
         lowest_combo_count=0,
         highest_combo_count=2,
         activation=int(NeuronActivationFn.Generalized_Logistic),
+        dtype=torch.float if _IS_TORCH_AVAILABLE else float,
         parameters=None,
+        **kwargs
     ):
         """
         Initialize a QrackNeuron layer for PyTorch with a power set of neurons connecting inputs to outputs.
@@ -175,186 +164,83 @@ class QrackNeuronTorchLayer(nn.Module if _IS_TORCH_AVAILABLE else object):
         super(QrackNeuronTorchLayer, self).__init__()
         if hidden_qubits is None:
             hidden_qubits = highest_combo_count
-        self.simulator = QrackSimulator(input_qubits + hidden_qubits + output_qubits)
+        self.simulator = QrackSimulator(input_qubits + hidden_qubits + output_qubits, **kwargs)
         self.simulators = []
         self.input_indices = list(range(input_qubits))
         self.hidden_indices = list(range(input_qubits, input_qubits + hidden_qubits))
-        self.output_indices = list(range(input_qubits + hidden_qubits, input_qubits + hidden_qubits + output_qubits))
+        self.output_indices = list(
+            range(input_qubits + hidden_qubits, input_qubits + hidden_qubits + output_qubits)
+        )
         self.activation = NeuronActivationFn(activation)
+        self.dtype = dtype
         self.apply_fn = QrackNeuronTorchFunction.apply
-        self.backward_fn = QrackNeuronTorchFunction._backward
 
         # Create neurons from all input combinations, projecting to coherent output qubits
-        neurons = [
-            QrackNeuronTorch(
-                QrackNeuron(self.simulator, input_subset, output_id, activation)
-            )
-            for output_id in self.output_indices
-            for k in range(lowest_combo_count, highest_combo_count + 1)
-            for input_subset in itertools.combinations(self.input_indices + self.hidden_indices, k)
-        ]
-        self.neurons = nn.ModuleList(neurons) if _IS_TORCH_AVAILABLE else neurons
-
-        # Set Qrack's internal parameters:
-        if parameters:
-            param_count = 0
-            self.weights = nn.ParameterList() if _IS_TORCH_AVAILABLE else []
-            for neuron_wrapper in self.neurons:
-                neuron = neuron_wrapper.neuron
-                p_count = 1 << len(neuron.controls)
-                neuron.set_angles(parameters[param_count : (param_count + p_count)])
-                self.weights.append(
-                    nn.Parameter(torch.tensor(parameters[param_count : (param_count + p_count)]))
-                    if _IS_TORCH_AVAILABLE else parameters[param_count : (param_count + p_count)]
-                )
-                param_count += p_count
-        else:
-            self.weights = nn.ParameterList() if _IS_TORCH_AVAILABLE else []
-            for neuron_wrapper in self.neurons:
-                neuron = neuron_wrapper.neuron
-                p_count = 1 << len(neuron.controls)
-                self.weights.append(nn.Parameter(torch.zeros(p_count)) if _IS_TORCH_AVAILABLE else ([0.0] * p_count))
+        neurons = []
+        param_count = 0
+        for output_id in self.output_indices:
+            for k in range(lowest_combo_count, highest_combo_count + 1):
+                for input_subset in itertools.combinations(self.input_indices, k):
+                    p_count = 1 << len(input_subset)
+                    angles = (
+                        (
+                            torch.tensor(
+                                parameters[param_count : (param_count + p_count)], dtype=dtype
+                            )
+                            if parameters
+                            else torch.zeros(p_count, dtype=dtype)
+                        )
+                    )
+                    neurons.append(
+                        QrackNeuronTorch(
+                            QrackNeuron(self.simulator, input_subset, output_id, activation), angles
+                        )
+                    )
+                    param_count += p_count
+        self.neurons = nn.ModuleList(neurons)
 
     def forward(self, x):
-        return QrackNeuronTorchLayerFunction.apply(x, self)
+        B = x.shape[0]
+        x = x.view(B, -1)
 
+        self.simulators.clear()
 
-class QrackNeuronTorchLayerFunction(Function if _IS_TORCH_AVAILABLE else object):
-    """Static forward/backward/apply functions for QrackNeuronTorch"""
+        self.simulator.reset_all()
+        # Prepare hidden predictors
+        for hidden_id in self.hidden_indices:
+            self.simulator.h(hidden_id)
+        # Prepare a maximally uncertain output state.
+        for output_id in self.output_indices:
+            self.simulator.h(output_id)
 
-    @staticmethod
-    def forward(ctx, x, neuron_layer):
-        # Save for backward
-        ctx.save_for_backward(x)
-        ctx.neuron_layer = neuron_layer
-
-        input_indices = neuron_layer.input_indices
-        hidden_indices = neuron_layer.hidden_indices
-        output_indices = neuron_layer.output_indices
-        simulators = neuron_layer.simulators
-        weights = neuron_layer.weights
-
-        if _IS_TORCH_AVAILABLE:
-            B = x.shape[0]
-            x = x.view(B, -1)
-        else:
-            B = len(x)
-
-        simulators.clear()
-        if _IS_TORCH_AVAILABLE:
-            for b in range(B):
-                simulator = neuron_layer.simulator.clone()
-                simulators.append(simulator)
-                for q, input_id in enumerate(input_indices):
-                    simulator.r(Pauli.PauliY, math.pi * x[b, q].item(), q)
-        else:
-            for b in range(B):
-                simulator = neuron_layer.simulator.clone()
-                simulators.append(simulator)
-                for q, input_id in enumerate(input_indices):
-                    simulator.r(Pauli.PauliY, math.pi * x[b][q], q)
-
-        y = [([0.0] * len(output_indices)) for _ in range(B)]
+        # Group neurons by output target once
+        by_out = {out: [] for out in self.output_indices}
+        for neuron_wrapper in self.neurons:
+            by_out[neuron_wrapper.neuron.target].append(neuron_wrapper)
+
+        batch_rows = []
         for b in range(B):
-            simulator = simulators[b]
-            # Prepare a maximally uncertain output state.
-            for output_id in output_indices:
-                simulator.h(output_id)
-            # Prepare hidden predictors
-            for h in hidden_indices:
-                simulator.h(h)
+            simulator = self.simulator.clone()
+            self.simulators.append(simulator)
 
-            # Set Qrack's internal parameters:
-            for idx, neuron_wrapper in enumerate(neuron_layer.neurons):
-                neuron_wrapper.neuron.simulator = simulator
-                neuron_layer.apply_fn(weights[idx], neuron_wrapper)
+            for q, input_id in enumerate(self.input_indices):
+                simulator.r(Pauli.PauliY, math.pi * x[b, q].item(), input_id)
 
-            for q, output_id in enumerate(output_indices):
-                y[b][q] = simulator.prob(output_id)
+            row = []
+            for out in self.output_indices:
+                phi = torch.tensor(init_phi, device=x.device, dtype=x.dtype)
 
-        if _IS_TORCH_AVAILABLE:
-            y = torch.tensor(y, dtype=torch.float32, device=x.device)
+                for neuron_wrapper in by_out[out]:
+                    neuron_wrapper.neuron.set_simulator(simulator)
+                    phi += self.apply_fn(
+                        neuron_wrapper.weights,
+                        neuron_wrapper.neuron
+                    ).squeeze()
 
-        return y
+                # Convert angle back to probability
+                p = torch.clamp(torch.sin(phi), min=0.0)
+                row.append(p)
 
-    @staticmethod
-    def backward(ctx, grad_output):
-        (x,) = ctx.saved_tensors
-        neuron_layer = ctx.neuron_layer
-
-        input_indices = neuron_layer.input_indices
-        hidden_indices = neuron_layer.hidden_indices
-        output_indices = neuron_layer.output_indices
-        simulators = neuron_layer.simulators
-        neurons = neuron_layer.neurons
-        backward_fn = neuron_layer.backward_fn
-
-        input_count = len(input_indices)
-        output_count = len(output_indices)
-
-        if _IS_TORCH_AVAILABLE:
-            B = x.shape[0]
-            x = x.view(B, -1)
-        else:
-            B = len(x)
-
-        # Uncompute prediction
-        if _IS_TORCH_AVAILABLE:
-            delta = torch.zeros((B, output_count, input_count), dtype=torch.float32, device=x.device)
-            for b in range(B):
-                simulator = simulators[b]
-                for neuron_wrapper in neurons:
-                    neuron = neuron_wrapper.neuron
-                    neuron.simulator = simulator
-                    angles = torch.tensor(neuron.get_angles(), dtype=torch.float32, device=x.device, requires_grad=True)
-                    o = output_indices.index(neuron.target)
-                    neuron_grad = backward_fn(angles, neuron_wrapper)
-                    for idx, c in enumerate(neuron.controls):
-                        if c not in input_indices:
-                            continue
-                        i = input_indices.index(c)
-                        delta[b, o, i] += neuron_grad[idx]
-        else:
-            delta = [[[0.0] * input_count for _ in range(output_count)] for _ in range(B)]
-            for b in range(B):
-                simulator = simulators[b]
-                for neuron_wrapper in neurons:
-                    neuron = neuron_wrapper.neuron
-                    neuron.simulator = simulator
-                    angles = neuron.get_angles()
-                    o = output_indices.index(neuron.target)
-                    neuron_grad = backward_fn(angles, neuron_wrapper)
-                    for idx, c in enumerate(neuron.controls):
-                        if c not in input_indices:
-                            continue
-                        i = input_indices.index(c)
-                        delta[b][o][i] += neuron_grad[idx]
-
-        # Uncompute output state prep
-        for simulator in simulators:
-            for output_id in output_indices:
-                simulator.h(output_id)
-            for h in hidden_indices:
-                simulator.h(output_id)
-
-        if _IS_TORCH_AVAILABLE:
-            for b in range(B):
-                simulator = simulators[b]
-                for q, input_id in enumerate(input_indices):
-                    simulator.r(Pauli.PauliY, -math.pi * x[b, q].item(), q)
-        else:
-            for b in range(B):
-                simulator = simulators[b]
-                for q, input_id in enumerate(input_indices):
-                    simulator.r(Pauli.PauliY, -math.pi * x[b][q].item(), q)
-
-        if _IS_TORCH_AVAILABLE:
-            grad_input = torch.matmul(grad_output.view(B, 1, -1), delta).view_as(x)
-        else:
-            grad_input = [[0.0] * output_count for _ in range(B)]
-            for b in range(B):
-                for o in range(output_indices):
-                    for i in range(input_indices):
-                        grad_input[b][o] += grad_output[b][o] * delta[b][o][i]
-
-        return grad_input, None
+            batch_rows.append(torch.stack(row))
+
+        return torch.stack(batch_rows)

pyqrack/qrack_simulator.py

@@ -57,9 +57,7 @@ class QrackSimulator:
         isPaged=True,
         isCpuGpuHybrid=True,
         isOpenCL=True,
-        isHostPointer=(
-            True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False
-        ),
+        isHostPointer=(True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False),
         isSparse=False,
         noise=0,
         pyzxCircuit=None,
@@ -100,7 +98,7 @@ class QrackSimulator:
                 isCpuGpuHybrid,
                 isOpenCL,
                 isHostPointer,
-                isSparse
+                isSparse,
             )
 
         self._throw_if_error()
@@ -593,7 +591,11 @@ class QrackSimulator:
                 "2x2 matrix 'm' in QrackSimulator.mcmtrx() must contain at least 4 elements."
             )
         Qrack.qrack_lib.MCMtrx(
-            self.sid, len(c), QrackSimulator._ulonglong_byref(c), QrackSimulator._complex_byref(m), q
+            self.sid,
+            len(c),
+            QrackSimulator._ulonglong_byref(c),
+            QrackSimulator._complex_byref(m),
+            q,
         )
         self._throw_if_error()
 
@@ -771,7 +773,11 @@ class QrackSimulator:
                 "2x2 matrix 'm' in QrackSimulator.macmtrx() must contain at least 4 elements."
             )
         Qrack.qrack_lib.MACMtrx(
-            self.sid, len(c), QrackSimulator._ulonglong_byref(c), QrackSimulator._complex_byref(m), q
+            self.sid,
+            len(c),
+            QrackSimulator._ulonglong_byref(c),
+            QrackSimulator._complex_byref(m),
+            q,
         )
         self._throw_if_error()
 
@@ -796,7 +802,12 @@ class QrackSimulator:
                 "2x2 matrix 'm' in QrackSimulator.ucmtrx() must contain at least 4 elements."
             )
         Qrack.qrack_lib.UCMtrx(
-            self.sid, len(c), QrackSimulator._ulonglong_byref(c), QrackSimulator._complex_byref(m), q, p
+            self.sid,
+            len(c),
+            QrackSimulator._ulonglong_byref(c),
+            QrackSimulator._complex_byref(m),
+            q,
+            p,
         )
         self._throw_if_error()
 
@@ -820,7 +831,11 @@ class QrackSimulator:
                 "Multiplex matrix 'm' in QrackSimulator.multiplex1_mtrx() must contain at least (4 * 2 ** len(c)) elements."
             )
         Qrack.qrack_lib.Multiplex1Mtrx(
-            self.sid, len(c), QrackSimulator._ulonglong_byref(c), q, QrackSimulator._complex_byref(m)
+            self.sid,
+            len(c),
+            QrackSimulator._ulonglong_byref(c),
+            q,
+            QrackSimulator._complex_byref(m),
         )
         self._throw_if_error()
 
@@ -978,9 +993,7 @@ class QrackSimulator:
         Raises:
             RuntimeError: QrackSimulator raised an exception.
         """
-        Qrack.qrack_lib.FSim(
-            self.sid, ctypes.c_double(th), ctypes.c_double(ph), qi1, qi2
-        )
+        Qrack.qrack_lib.FSim(self.sid, ctypes.c_double(th), ctypes.c_double(ph), qi1, qi2)
         self._throw_if_error()
 
     def cswap(self, c, qi1, qi2):
@@ -1831,7 +1844,10 @@ class QrackSimulator:
             )
 
         Qrack.qrack_lib.Hash(
-            self.sid, len(q), QrackSimulator._ulonglong_byref(q), QrackSimulator._to_ubyte(len(q), t)
+            self.sid,
+            len(q),
+            QrackSimulator._ulonglong_byref(q),
+            QrackSimulator._to_ubyte(len(q), t),
         )
         self._throw_if_error()
 
@@ -2316,7 +2332,9 @@ class QrackSimulator:
         amp_count = 1 << len(q)
         sqr_amp_count = amp_count * amp_count
         flat_rdm = QrackSimulator._qrack_complex_byref([complex(0, 0)] * sqr_amp_count)
-        Qrack.qrack_lib.OutReducedDensityMatrix(self.sid, len(q), QrackSimulator._ulonglong_byref(q), flat_rdm)
+        Qrack.qrack_lib.OutReducedDensityMatrix(
+            self.sid, len(q), QrackSimulator._ulonglong_byref(q), flat_rdm
+        )
         self._throw_if_error()
         return [complex(r, i) for r, i in QrackSimulator._pairwise(flat_rdm)]
 
@@ -2541,7 +2559,11 @@ class QrackSimulator:
             raise RuntimeError("factorized_expectation argument lengths do not match.")
         m = max([(x.bit_length() + 63) // 64 for x in c])
         result = Qrack.qrack_lib.FactorizedExpectation(
-            self.sid, len(q), QrackSimulator._ulonglong_byref(q), m, QrackSimulator._to_ulonglong(m, c)
+            self.sid,
+            len(q),
+            QrackSimulator._ulonglong_byref(q),
+            m,
+            QrackSimulator._to_ulonglong(m, c),
         )
         self._throw_if_error()
         return result
@@ -2566,12 +2588,15 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError(
-                "factorized_expectation_rdm argument lengths do not match."
-            )
+            raise RuntimeError("factorized_expectation_rdm argument lengths do not match.")
         m = max([(x.bit_length() + 63) // 64 for x in c])
         result = Qrack.qrack_lib.FactorizedExpectationRdm(
-            self.sid, len(q), QrackSimulator._ulonglong_byref(q), m, QrackSimulator._to_ulonglong(m, c), r
+            self.sid,
+            len(q),
+            QrackSimulator._ulonglong_byref(q),
+            m,
+            QrackSimulator._to_ulonglong(m, c),
+            r,
         )
         self._throw_if_error()
         return result
@@ -2594,9 +2619,7 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError(
-                "factorized_expectation_rdm argument lengths do not match."
-            )
+            raise RuntimeError("factorized_expectation_rdm argument lengths do not match.")
         result = Qrack.qrack_lib.FactorizedExpectationFp(
             self.sid, len(q), QrackSimulator._ulonglong_byref(q), QrackSimulator._real1_byref(c)
         )
@@ -2623,9 +2646,7 @@ class QrackSimulator:
             Expectation value
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError(
-                "factorized_expectation_fp_rdm argument lengths do not match."
-            )
+            raise RuntimeError("factorized_expectation_fp_rdm argument lengths do not match.")
         result = Qrack.qrack_lib.FactorizedExpectationFpRdm(
             self.sid, len(q), QrackSimulator._ulonglong_byref(q), QrackSimulator._real1_byref(c), r
         )
@@ -2836,7 +2857,11 @@ class QrackSimulator:
             raise RuntimeError("factorized_variance argument lengths do not match.")
         m = max([(x.bit_length() + 63) // 64 for x in c])
         result = Qrack.qrack_lib.FactorizedVariance(
-            self.sid, len(q), QrackSimulator._ulonglong_byref(q), m, QrackSimulator._to_ulonglong(m, c)
+            self.sid,
+            len(q),
+            QrackSimulator._ulonglong_byref(q),
+            m,
+            QrackSimulator._to_ulonglong(m, c),
         )
         self._throw_if_error()
         return result
@@ -2864,7 +2889,12 @@ class QrackSimulator:
             raise RuntimeError("factorized_variance_rdm argument lengths do not match.")
         m = max([(x.bit_length() + 63) // 64 for x in c])
         result = Qrack.qrack_lib.FactorizedVarianceRdm(
-            self.sid, len(q), QrackSimulator._ulonglong_byref(q), m, QrackSimulator._to_ulonglong(m, c), r
+            self.sid,
+            len(q),
+            QrackSimulator._ulonglong_byref(q),
+            m,
+            QrackSimulator._to_ulonglong(m, c),
+            r,
         )
         self._throw_if_error()
         return result
@@ -2914,9 +2944,7 @@ class QrackSimulator:
             variance
         """
         if (len(q) << 1) != len(c):
-            raise RuntimeError(
-                "factorized_variance_fp_rdm argument lengths do not match."
-            )
+            raise RuntimeError("factorized_variance_fp_rdm argument lengths do not match.")
         result = Qrack.qrack_lib.FactorizedVarianceFpRdm(
             self.sid, len(q), QrackSimulator._ulonglong_byref(q), QrackSimulator._real1_byref(c), r
         )
@@ -3551,9 +3579,7 @@ class QrackSimulator:
             "swap",
         ]
         try:
-            circ = transpile(
-                clifford_circ, basis_gates=basis_gates, optimization_level=2
-            )
+            circ = transpile(clifford_circ, basis_gates=basis_gates, optimization_level=2)
         except:
             circ = clifford_circ
 
@@ -3649,9 +3675,7 @@ class QrackSimulator:
                         )
                     elif op.name == "h":
                         non_clifford = np.matmul(
-                            np.array(
-                                [[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128
-                            ),
+                            np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128),
                             non_clifford,
                         )
                     elif op.name == "x":
@@ -3759,9 +3783,7 @@ class QrackSimulator:
                     j += 1
                     continue
 
-                if (q1 == i) and (
-                    (op.name == "cx") or (op.name == "cy") or (op.name == "cz")
-                ):
+                if (q1 == i) and ((op.name == "cx") or (op.name == "cy") or (op.name == "cz")):
                     if np.isclose(np.abs(non_clifford[0][1]), 0) and np.isclose(
                         np.abs(non_clifford[1][0]), 0
                     ):
@@ -3827,9 +3849,7 @@ class QrackSimulator:
                     elif op.name == "h":
                         non_clifford = np.matmul(
                             non_clifford,
-                            np.array(
-                                [[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128
-                            ),
+                            np.array([[sqrt1_2, sqrt1_2], [sqrt1_2, -sqrt1_2]], np.complex128),
                         )
                     elif op.name == "x":
                         non_clifford = np.matmul(
@@ -4019,12 +4039,8 @@ class QrackSimulator:
             qasm = qasm3.dumps(circ)
         except:
             qasm = circ.qasm()
-        qasm = qasm.replace(
-            "qreg q[" + str(circ.width()) + "];", "qreg q[" + str(width) + "];"
-        )
-        highest_index = max(
-            [int(x) for x in re.findall(r"\[(.*?)\]", qasm) if x.isdigit()]
-        )
+        qasm = qasm.replace("qreg q[" + str(circ.width()) + "];", "qreg q[" + str(width) + "];")
+        highest_index = max([int(x) for x in re.findall(r"\[(.*?)\]", qasm) if x.isdigit()])
         if highest_index != width:
             qasm = qasm.replace(
                 "qreg q[" + str(width) + "];", "qreg q[" + str(highest_index) + "];"
@@ -4139,17 +4155,11 @@ class QrackSimulator:
                 (-1 * float(operation.params[1])) + math.pi / 2,
             )
         elif name == "rx":
-            self._sim.r(
-                Pauli.PauliX, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliX, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "ry":
-            self._sim.r(
-                Pauli.PauliY, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliY, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "rz":
-            self._sim.r(
-                Pauli.PauliZ, float(operation.params[0]), operation.qubits[0]._index
-            )
+            self._sim.r(Pauli.PauliZ, float(operation.params[0]), operation.qubits[0]._index)
         elif name == "h":
             self._sim.h(operation.qubits[0]._index)
         elif name == "x":
@@ -4201,21 +4211,13 @@ class QrackSimulator:
                 float(operation.params[2]),
             )
         elif name == "cx":
-            self._sim.mcx(
-                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
-            )
+            self._sim.mcx([q._index for q in operation.qubits[0:1]], operation.qubits[1]._index)
         elif name == "cy":
-            self._sim.mcy(
-                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
-            )
+            self._sim.mcy([q._index for q in operation.qubits[0:1]], operation.qubits[1]._index)
         elif name == "cz":
-            self._sim.mcz(
-                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
-            )
+            self._sim.mcz([q._index for q in operation.qubits[0:1]], operation.qubits[1]._index)
         elif name == "ch":
-            self._sim.mch(
-                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
-            )
+            self._sim.mch([q._index for q in operation.qubits[0:1]], operation.qubits[1]._index)
         elif name == "cp":
             self._sim.mcmtrx(
                 [q._index for q in operation.qubits[0:1]],
@@ -4241,34 +4243,20 @@ class QrackSimulator:
                 operation.qubits[1]._index,
             )
         elif name == "dcx":
-            self._sim.mcx(
-                [q._index for q in operation.qubits[0:1]], operation.qubits[1]._index
-            )
+            self._sim.mcx([q._index for q in operation.qubits[0:1]], operation.qubits[1]._index)
             self._sim.mcx(operation.qubits[1:2]._index, operation.qubits[0]._index)
         elif name == "ccx":
-            self._sim.mcx(
-                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
-            )
+            self._sim.mcx([q._index for q in operation.qubits[0:2]], operation.qubits[2]._index)
         elif name == "ccy":
-            self._sim.mcy(
-                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
-            )
+            self._sim.mcy([q._index for q in operation.qubits[0:2]], operation.qubits[2]._index)
         elif name == "ccz":
-            self._sim.mcz(
-                [q._index for q in operation.qubits[0:2]], operation.qubits[2]._index
-            )
+            self._sim.mcz([q._index for q in operation.qubits[0:2]], operation.qubits[2]._index)
         elif name == "mcx":
-            self._sim.mcx(
-                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
-            )
+            self._sim.mcx([q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index)
         elif name == "mcy":
-            self._sim.mcy(
-                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
-            )
+            self._sim.mcy([q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index)
         elif name == "mcz":
-            self._sim.mcz(
-                [q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index
-            )
+            self._sim.mcz([q._index for q in operation.qubits[0:-1]], operation.qubits[-1]._index)
         elif name == "swap":
             self._sim.swap(operation.qubits[0]._index, operation.qubits[1]._index)
         elif name == "iswap":
@@ -4320,9 +4308,9 @@ class QrackSimulator:
                         cregbit = clbit
 
                     regbit = 1 << cregbit
-                    self._classical_register = (
-                        self._classical_register & (~regbit)
-                    ) | (qubit_outcome << cregbit)
+                    self._classical_register = (self._classical_register & (~regbit)) | (
+                        qubit_outcome << cregbit
+                    )
 
         elif name == "bfunc":
             mask = int(operation.mask, 16)
@@ -4437,9 +4425,7 @@ class QrackSimulator:
             if operation.name == "id" or operation.name == "barrier":
                 continue
 
-            if is_initializing and (
-                (operation.name == "measure") or (operation.name == "reset")
-            ):
+            if is_initializing and ((operation.name == "measure") or (operation.name == "reset")):
                 continue
 
             is_initializing = False
@@ -4497,9 +4483,7 @@ class QrackSimulator:
                 self._sample_cregbits = []
 
         if self._sample_measure and (len(self._sample_qubits) > 0):
-            _data = self._add_sample_measure(
-                self._sample_qubits, self._sample_clbits, self._shots
-            )
+            _data = self._add_sample_measure(self._sample_qubits, self._sample_clbits, self._shots)
 
         del self._sim
 

pyqrack/qrack_system/qrack_system.py

@@ -28,13 +28,9 @@ class QrackSystem:
         elif _platform == "win32":
             shared_lib_path = os.path.dirname(__file__) + "/qrack_lib/qrack_pinvoke.dll"
         elif _platform == "darwin":
-            shared_lib_path = (
-                os.path.dirname(__file__) + "/qrack_lib/libqrack_pinvoke.dylib"
-            )
+            shared_lib_path = os.path.dirname(__file__) + "/qrack_lib/libqrack_pinvoke.dylib"
         else:
-            shared_lib_path = (
-                os.path.dirname(__file__) + "/qrack_lib/libqrack_pinvoke.so"
-            )
+            shared_lib_path = os.path.dirname(__file__) + "/qrack_lib/libqrack_pinvoke.so"
 
         try:
             self.qrack_lib = CDLL(shared_lib_path)
@@ -50,9 +46,7 @@ class QrackSystem:
                 self.qrack_lib = CDLL(shared_lib_path)
             except Exception as e:
                 if _platform == "win32":
-                    shared_lib_path = (
-                        "C:/Program Files (x86)/Qrack/bin/qrack_pinvoke.dll"
-                    )
+                    shared_lib_path = "C:/Program Files (x86)/Qrack/bin/qrack_pinvoke.dll"
                 elif _platform == "darwin":
                     shared_lib_path = "/usr/lib/qrack/libqrack_pinvoke.dylib"
                 else:
@@ -97,12 +91,22 @@ class QrackSystem:
             self.qrack_lib.InKet.argtypes = [c_ulonglong, POINTER(c_float)]
             self.qrack_lib.OutKet.argtypes = [c_ulonglong, POINTER(c_float)]
             self.qrack_lib.OutProbs.argtypes = [c_ulonglong, POINTER(c_float)]
-            self.qrack_lib.OutReducedDensityMatrix.argtypes = [c_ulonglong, c_ulonglong, POINTER(c_ulonglong), POINTER(c_float)]
+            self.qrack_lib.OutReducedDensityMatrix.argtypes = [
+                c_ulonglong,
+                c_ulonglong,
+                POINTER(c_ulonglong),
+                POINTER(c_float),
+            ]
         else:
             self.qrack_lib.InKet.argtypes = [c_ulonglong, POINTER(c_double)]
             self.qrack_lib.OutKet.argtypes = [c_ulonglong, POINTER(c_double)]
             self.qrack_lib.OutProbs.argtypes = [c_ulonglong, POINTER(c_double)]
-            self.qrack_lib.OutReducedDensityMatrix.argtypes = [c_ulonglong, c_ulonglong, POINTER(c_ulonglong), POINTER(c_double)]
+            self.qrack_lib.OutReducedDensityMatrix.argtypes = [
+                c_ulonglong,
+                c_ulonglong,
+                POINTER(c_ulonglong),
+                POINTER(c_double),
+            ]
 
         self.qrack_lib.init.restype = c_ulonglong
         self.qrack_lib.init.argtypes = []
@@ -129,7 +133,7 @@ class QrackSystem:
             c_bool,
             c_bool,
             c_bool,
-            c_bool
+            c_bool,
         ]
 
         self.qrack_lib.init_count_stabilizer.restype = c_ulonglong
@@ -1251,6 +1255,9 @@ class QrackSystem:
         self.qrack_lib.destroy_qneuron.restype = None
         self.qrack_lib.destroy_qneuron.argtypes = [c_ulonglong]
 
+        self.qrack_lib.set_qneuron_sim.restype = None
+        self.qrack_lib.set_qneuron_sim.argtypes = [c_ulonglong, c_ulonglong]
+
         self.qrack_lib.set_qneuron_angles.restype = None
         self.qrack_lib.get_qneuron_angles.restype = None
 

pyqrack/stats/load_quantized_data.py

@@ -20,9 +20,7 @@ def load_data(sim, index_bits, value_bits, data):
         Value error: Length of value_bits does not match data feature column count!
     """
     if (len(data) > 0) and (len(value_bits) != len(data[0])):
-        raise ValueError(
-            "Length of value_bits does not match data feature column count!"
-        )
+        raise ValueError("Length of value_bits does not match data feature column count!")
 
     for i in range(index_bits):
         if sim.m(i):

pyqrack/stats/quantize_by_range.py

@@ -28,9 +28,7 @@ try:
                 min_val, max_val = data[:, i].min(), data[:, i].max()
                 thresholds = np.linspace(min_val, max_val, n_bins + 1)[1:-1]
                 bins = np.digitize(data[:, i], bins=thresholds)
-                bin_bits = ((bins[:, None] & (1 << np.arange(bits)[::-1])) > 0).astype(
-                    int
-                )
+                bin_bits = ((bins[:, None] & (1 << np.arange(bits)[::-1])) > 0).astype(int)
                 new_features.append(bin_bits)
             else:
                 new_features.append(data[:, i][:, None])  # Keep original
@@ -51,6 +49,4 @@ except ImportError:
         Returns:
             np.ndarray: Transformed data with selected features replaced by binary bit columns.
         """
-        raise NotImplementedError(
-            "You must have numpy installed to use quantize_by_percentile()!"
-        )
+        raise NotImplementedError("You must have numpy installed to use quantize_by_percentile()!")

{pyqrack_complex128-1.78.3.dist-info → pyqrack_complex128-1.80.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyqrack-complex128
-Version: 1.78.3
+Version: 1.80.2
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano
@@ -32,6 +32,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Quantum Computing
 Description-Content-Type: text/markdown
 License-File: LICENSE

pyqrack_complex128-1.80.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+pyqrack/__init__.py,sha256=P-J0gPYsYfeoBdJA0EqGwrmGwM0-hyI6pqb0Qd40Rpg,790
+pyqrack/neuron_activation_fn.py,sha256=fQTTFfsvwcot_43Vopacot47IV2Rxk8pelUyuzwpXPs,593
+pyqrack/pauli.py,sha256=wg500wDOwdIU4lEVJoMmjtbAdmtakZYzLPjdzC2rwUQ,654
+pyqrack/qrack_ace_backend.py,sha256=-LSEX-M_hg-17LL27rLh8fpwuJaMEQeQpXzYoiuC21A,49143
+pyqrack/qrack_circuit.py,sha256=jcelcoRrAWJBs9OrjBKkCba1MEIUcXeXDMKH3iwOl2Y,19778
+pyqrack/qrack_neuron.py,sha256=TQl3jNFu5E41yuILBQIeSeagr4mRAPakKufFvniJOOc,12219
+pyqrack/qrack_neuron_torch_layer.py,sha256=zAcB_xGnCGKZQSJQLth-nyYob-ewdOs4EEmms6lr4nw,9715
+pyqrack/qrack_simulator.py,sha256=41nQEjC8IRhPz2_McpH9G-1T7V1aFK82RRKLxt1oJeo,148879
+pyqrack/qrack_stabilizer.py,sha256=O-7VJ9Vw4h25PK_kesSjIqHXGSo8lLrQLIyGgmzG7Co,2124
+pyqrack/quimb_circuit_type.py,sha256=Sk-Tmn38kUYmAkJJ75btWuhYZyTXOOezmowFhfdiGDc,621
+pyqrack/qrack_system/__init__.py,sha256=-oZ9dsb1hixsnrkUJRY_C5DzQ_l6MtifF_Z465BgqV4,334
+pyqrack/qrack_system/qrack_system.py,sha256=2Me1K7z74dzx1u5wcLpNK8mVrgn3aA1fCoj4jcf2guQ,44155
+pyqrack/qrack_system/qrack_cl_precompile/qrack_cl_precompile,sha256=oVv74H7l9G0k6YTYFqYWygQ9XV-xt7IcyPwZlpudbuw,36224
+pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.9.35.1.dylib,sha256=NiRG8bQF2Ve0A4Up9jux6sf3krHOCbl8v1VENOg7cn8,3660640
+pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.dylib,sha256=NiRG8bQF2Ve0A4Up9jux6sf3krHOCbl8v1VENOg7cn8,3660640
+pyqrack/stats/__init__.py,sha256=Hla85my2fY_roR9lIjGBVpEG7ySOTMwjWa8D6-kgCnY,276
+pyqrack/stats/load_quantized_data.py,sha256=10-ZULlnSX45br7fDtJuiCzcMTAL4eI3QyhSENXZjgM,1162
+pyqrack/stats/quantize_by_range.py,sha256=zPLMNuuyzMPvB-K9Ukc-RjzIzwCsZkzuT2gZneCeCBg,2210
+pyqrack_complex128-1.80.2.dist-info/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
+pyqrack_complex128-1.80.2.dist-info/METADATA,sha256=H-Lr2s3JeqIj0Z29Bnuke42tFeoTMaShiVSRdQgOjvA,5992
+pyqrack_complex128-1.80.2.dist-info/WHEEL,sha256=BM14wstXunLvpW3hePaerLq1eZfN4NnYgS3CIXR7_AM,106
+pyqrack_complex128-1.80.2.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
+pyqrack_complex128-1.80.2.dist-info/RECORD,,

pyqrack_complex128-1.78.3.dist-info/RECORD

@@ -1,23 +0,0 @@
-pyqrack/__init__.py,sha256=m5hflZS-sICsMPlwri4H6x8CF0ZEa0WBAVrna89SyTk,825
-pyqrack/neuron_activation_fn.py,sha256=fQTTFfsvwcot_43Vopacot47IV2Rxk8pelUyuzwpXPs,593
-pyqrack/pauli.py,sha256=wg500wDOwdIU4lEVJoMmjtbAdmtakZYzLPjdzC2rwUQ,654
-pyqrack/qrack_ace_backend.py,sha256=D5scJXQuqbBKTPr5ycDr5wpxdk6TEwz7fhZ5YCcsTL8,49677
-pyqrack/qrack_circuit.py,sha256=UvdcmF5GZQEf5pLL8fxqEofLgms3yBBWFPwAC-pVh5I,19830
-pyqrack/qrack_neuron.py,sha256=XanXEaY1sZvTpFmMUlaL41pxFwiQjAeS3V82ugmwyqc,11786
-pyqrack/qrack_neuron_torch_layer.py,sha256=DjESsSiNLFW96a3MRc4H9mKQ96o51R2O9-q2rYD6Oyc,14805
-pyqrack/qrack_simulator.py,sha256=5Io-UHx11faJfgiMtUciqEGtMNN_RBvcwgyk8lBfkDw,149271
-pyqrack/qrack_stabilizer.py,sha256=O-7VJ9Vw4h25PK_kesSjIqHXGSo8lLrQLIyGgmzG7Co,2124
-pyqrack/quimb_circuit_type.py,sha256=Sk-Tmn38kUYmAkJJ75btWuhYZyTXOOezmowFhfdiGDc,621
-pyqrack/qrack_system/__init__.py,sha256=-oZ9dsb1hixsnrkUJRY_C5DzQ_l6MtifF_Z465BgqV4,334
-pyqrack/qrack_system/qrack_system.py,sha256=q6kjSCjTvuh5sLru-tUoCoGtD8Y3tL3J2yQahXuEQ1s,43976
-pyqrack/qrack_system/qrack_cl_precompile/qrack_cl_precompile,sha256=oVv74H7l9G0k6YTYFqYWygQ9XV-xt7IcyPwZlpudbuw,36224
-pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.9.34.5.dylib,sha256=UflibXjUSaWJZd2d1vY_y3IvwnE-B12SnkCoeB7A5FM,3660608
-pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.dylib,sha256=UflibXjUSaWJZd2d1vY_y3IvwnE-B12SnkCoeB7A5FM,3660608
-pyqrack/stats/__init__.py,sha256=Hla85my2fY_roR9lIjGBVpEG7ySOTMwjWa8D6-kgCnY,276
-pyqrack/stats/load_quantized_data.py,sha256=z12u9F7Nt3P-i44nY1xxvso_klS6WIHS3iqq7R2_lqE,1184
-pyqrack/stats/quantize_by_range.py,sha256=UM0_7jJDdQ7g30cR3UQAxkbzkqrmsy1oUfqg0h11FUY,2270
-pyqrack_complex128-1.78.3.dist-info/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
-pyqrack_complex128-1.78.3.dist-info/METADATA,sha256=M0lvm5jPx1sbFvZnNH6yW24rrXzW3jKJdLvNXqb2nDk,5890
-pyqrack_complex128-1.78.3.dist-info/WHEEL,sha256=BM14wstXunLvpW3hePaerLq1eZfN4NnYgS3CIXR7_AM,106
-pyqrack_complex128-1.78.3.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
-pyqrack_complex128-1.78.3.dist-info/RECORD,,