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

pyqrack/__init__.py

@@ -10,9 +10,10 @@ from .qrack_ace_backend import QrackAceBackend
 from .qrack_circuit import QrackCircuit
 from .qrack_neuron import QrackNeuron
 from .qrack_neuron_torch_layer import (
-    QrackTorchNeuron,
-    QrackNeuronFunction,
+    QrackNeuronTorch,
+    QrackNeuronTorchFunction,
     QrackNeuronTorchLayer,
+    QrackNeuronTorchLayerFunction,
 )
 from .qrack_simulator import QrackSimulator
 from .qrack_stabilizer import QrackStabilizer

pyqrack/qrack_ace_backend.py

@@ -139,6 +139,12 @@ class LHVQubit:
         new_y = 2 * (rho_prime[0][1].imag - rho_prime[1][0].imag)
         new_z = 2 * rho_prime[0][0].real - 1  # since Tr(ρ') = 1
 
+        p = math.sqrt(new_x**2 + new_y**2 + new_z**2)
+
+        new_x /= p
+        new_y /= p
+        new_z /= p
+
         self.bloch = [new_x, new_y, new_z]
 
     def prob(self, basis=Pauli.PauliZ):
@@ -202,7 +208,6 @@ class QrackAceBackend:
         sim(QrackSimulator): Array of simulators corresponding to "patches" between boundary rows.
         long_range_columns(int): How many ideal rows between QEC boundary rows?
         is_transpose(bool): Rows are long if False, columns are long if True
-        correction_bias(float): Bias magnitude and direction during pseudo-QEC
     """
 
     def __init__(
@@ -211,7 +216,6 @@ class QrackAceBackend:
         long_range_columns=4,
         long_range_rows=4,
         is_transpose=False,
-        correction_bias=0,
         isTensorNetwork=False,
         isSchmidtDecomposeMulti=False,
         isSchmidtDecompose=True,
@@ -240,7 +244,6 @@ class QrackAceBackend:
         self.long_range_columns = long_range_columns
         self.long_range_rows = long_range_rows
         self.is_transpose = is_transpose
-        self.correction_bias = correction_bias
 
         fppow = 5
         if "QRACK_FPPOW" in os.environ:
@@ -429,7 +432,8 @@ class QrackAceBackend:
     def _unpack(self, lq):
         return self._qubits[lq]
 
-    def _get_qb_lhv_indices(self, hq):
+    @staticmethod
+    def _get_qb_lhv_indices(hq):
         qb = []
         if len(hq) < 2:
             qb = [0]
@@ -443,15 +447,16 @@ class QrackAceBackend:
 
         return qb, lhv
 
-    def _get_lhv_bloch_angles(self, sim):
+    @staticmethod
+    def _get_lhv_bloch_angles(sim):
         # Z axis
-        z = 1 - 2 * sim.prob(Pauli.PauliZ)
+        z = sim.bloch[2]
 
         # X axis
-        x = 1 - 2 * sim.prob(Pauli.PauliX)
+        x = sim.bloch[0]
 
         # Y axis
-        y = 1 - 2 * sim.prob(Pauli.PauliY)
+        y = sim.bloch[1]
 
         inclination = math.atan2(math.sqrt(x**2 + y**2), z)
         azimuth = math.atan2(y, x)
@@ -483,9 +488,7 @@ class QrackAceBackend:
 
         return azimuth, inclination
 
-    def _rotate_to_bloch(
-        self, hq, delta_azimuth, delta_inclination
-    ):
+    def _rotate_to_bloch(self, hq, delta_azimuth, delta_inclination):
         sim = self.sim[hq[0]]
         q = hq[1]
 
@@ -502,10 +505,8 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11], q)
 
-
-    def _rotate_lhv_to_bloch(
-        self, sim, delta_azimuth, delta_inclination
-    ):
+    @staticmethod
+    def _rotate_lhv_to_bloch(sim, delta_azimuth, delta_inclination):
         # Apply rotation as "Azimuth, Inclination" (AI)
         cosA = math.cos(delta_azimuth)
         sinA = math.sin(delta_azimuth)
@@ -519,14 +520,13 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11])
 
-
     def _correct(self, lq, phase=False, skip_rotation=False):
         hq = self._unpack(lq)
 
         if len(hq) == 1:
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         if phase:
             for q in qb:
@@ -575,7 +575,7 @@ class QrackAceBackend:
                 a, i = [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]
                 a[0], i[0] = self._get_bloch_angles(hq[0])
                 a[1], i[1] = self._get_bloch_angles(hq[1])
-                a[2], i[2] = self._get_lhv_bloch_angles(hq[2])
+                a[2], i[2] = QrackAceBackend._get_lhv_bloch_angles(hq[2])
                 a[3], i[3] = self._get_bloch_angles(hq[3])
                 a[4], i[4] = self._get_bloch_angles(hq[4])
 
@@ -591,12 +591,12 @@ class QrackAceBackend:
                 i_target /= 5
                 for x in range(5):
                     if x == 2:
-                        self._rotate_lhv_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+                        QrackAceBackend._rotate_lhv_to_bloch(
+                            hq[x], a_target - a[x], i_target - i[x]
+                        )
                     else:
                         self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
 
-                self.apply_magnetic_bias([lq], self.correction_bias)
-
         else:
             # RMS
             p = [
@@ -620,7 +620,7 @@ class QrackAceBackend:
                 a, i = [0, 0, 0], [0, 0, 0]
                 a[0], i[0] = self._get_bloch_angles(hq[0])
                 a[1], i[1] = self._get_bloch_angles(hq[1])
-                a[2], i[2] = self._get_lhv_bloch_angles(hq[2])
+                a[2], i[2] = QrackAceBackend._get_lhv_bloch_angles(hq[2])
 
                 a_target = 0
                 i_target = 0
@@ -634,12 +634,12 @@ class QrackAceBackend:
                 i_target /= 3
                 for x in range(3):
                     if x == 2:
-                        self._rotate_lhv_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+                        QrackAceBackend._rotate_lhv_to_bloch(
+                            hq[x], a_target - a[x], i_target - i[x]
+                        )
                     else:
                         self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
 
-                self.apply_magnetic_bias([lq], self.correction_bias)
-
         if phase:
             for q in qb:
                 b = hq[q]
@@ -656,14 +656,18 @@ class QrackAceBackend:
             for c in range(len(hq)):
                 h = hq[c]
                 if c == 2:
-                    a, i = self._get_lhv_bloch_angles(h)
-                    self._rotate_lhv_to_bloch(
-                        h, math.atan(math.tan(a) * b) - a, math.atan(math.tan(i) * b) - i
+                    a, i = QrackAceBackend._get_lhv_bloch_angles(h)
+                    QrackAceBackend._rotate_lhv_to_bloch(
+                        h,
+                        math.atan(math.tan(a) * b) - a,
+                        math.atan(math.tan(i) * b) - i,
                     )
                 else:
                     a, i = self._get_bloch_angles(h)
                     self._rotate_to_bloch(
-                        h, math.atan(math.tan(a) * b) - a, math.atan(math.tan(i) * b) - i
+                        h,
+                        math.atan(math.tan(a) * b) - a,
+                        math.atan(math.tan(i) * b) - i,
                     )
 
     def u(self, lq, th, ph, lm):
@@ -673,7 +677,7 @@ class QrackAceBackend:
             self.sim[b[0]].u(b[1], th, ph, lm)
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -692,7 +696,7 @@ class QrackAceBackend:
             self.sim[b[0]].r(p, th, b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -720,7 +724,7 @@ class QrackAceBackend:
 
         self._correct(lq)
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -738,7 +742,7 @@ class QrackAceBackend:
             self.sim[b[0]].s(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -754,7 +758,7 @@ class QrackAceBackend:
             self.sim[b[0]].adjs(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -770,7 +774,7 @@ class QrackAceBackend:
             self.sim[b[0]].x(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -786,7 +790,7 @@ class QrackAceBackend:
             self.sim[b[0]].y(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -802,7 +806,7 @@ class QrackAceBackend:
             self.sim[b[0]].z(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -818,7 +822,7 @@ class QrackAceBackend:
             self.sim[b[0]].t(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -834,7 +838,7 @@ class QrackAceBackend:
             self.sim[b[0]].adjt(b[1])
             return
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -916,8 +920,8 @@ class QrackAceBackend:
 
         self._correct(lq1)
 
-        qb1, lhv1 = self._get_qb_lhv_indices(hq1)
-        qb2, lhv2 = self._get_qb_lhv_indices(hq2)
+        qb1, lhv1 = QrackAceBackend._get_qb_lhv_indices(hq1)
+        qb2, lhv2 = QrackAceBackend._get_qb_lhv_indices(hq2)
         # Apply cross coupling on hardware qubits first
         self._apply_coupling(pauli, anti, qb1, lhv1, hq1, qb2, lhv2, hq2, lq1_lr)
         # Apply coupling to the local-hidden-variable target
@@ -1064,7 +1068,7 @@ class QrackAceBackend:
         p = self.prob(lq)
         result = ((p + self._epsilon) >= 1) or (random.random() < p)
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -1090,7 +1094,7 @@ class QrackAceBackend:
 
         self._correct(lq)
 
-        qb, lhv = self._get_qb_lhv_indices(hq)
+        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -1443,6 +1447,7 @@ class QrackAceBackend:
 
         return _data
 
+    @staticmethod
     def get_qiskit_basis_gates():
         return [
             "id",

pyqrack/qrack_circuit.py

@@ -59,7 +59,7 @@ class QrackCircuit:
             self.cid = Qrack.qrack_lib.qcircuit_inverse(clone_cid)
         elif len(past_light_cone) > 0:
             self.cid = Qrack.qrack_lib.qcircuit_past_light_cone(
-                clone_cid, len(past_light_cone), self._ulonglong_byref(past_light_cone)
+                clone_cid, len(past_light_cone), QrackCircuit._ulonglong_byref(past_light_cone)
             )
         else:
             self.cid = Qrack.qrack_lib.init_qcircuit_clone(clone_cid)
@@ -69,16 +69,20 @@ class QrackCircuit:
             Qrack.qrack_lib.destroy_qcircuit(self.cid)
             self.cid = None
 
-    def _ulonglong_byref(self, a):
+    @staticmethod
+    def _ulonglong_byref(a):
         return (ctypes.c_ulonglong * len(a))(*a)
 
-    def _double_byref(self, a):
+    @staticmethod
+    def _double_byref(a):
         return (ctypes.c_double * len(a))(*a)
 
-    def _complex_byref(self, a):
+    @staticmethod
+    def _complex_byref(a):
         t = [(c.real, c.imag) for c in a]
-        return self._double_byref([float(item) for sublist in t for item in sublist])
+        return QrackCircuit._double_byref([float(item) for sublist in t for item in sublist])
 
+    @staticmethod
     def _mtrx_to_u4(m):
         nrm = abs(m[0])
         if (nrm * nrm) < sys.float_info.epsilon:
@@ -103,6 +107,7 @@ class QrackCircuit:
 
         return th, ph, lm, np.angle(phase)
 
+    @staticmethod
     def _u3_to_mtrx(params):
         th = float(params[0])
         ph = float(params[1])
@@ -115,6 +120,7 @@ class QrackCircuit:
 
         return [c + 0j, -el * s, ep * s, ep * el * c]
 
+    @staticmethod
     def _u4_to_mtrx(params):
         m = QrackCircuit._u3_to_mtrx(params)
         g = np.exp(1j * float(params[3]))
@@ -123,6 +129,7 @@ class QrackCircuit:
 
         return m
 
+    @staticmethod
     def _make_mtrx_unitary(m):
         return QrackCircuit._u4_to_mtrx(QrackCircuit._mtrx_to_u4(m))
 
@@ -190,7 +197,7 @@ class QrackCircuit:
             raise ValueError(
                 "2x2 matrix 'm' in QrackCircuit.mtrx() must contain at least 4 elements."
             )
-        Qrack.qrack_lib.qcircuit_append_1qb(self.cid, self._complex_byref(m), q)
+        Qrack.qrack_lib.qcircuit_append_1qb(self.cid, QrackCircuit._complex_byref(m), q)
 
     def ucmtrx(self, c, m, q, p):
         """Multi-controlled single-target-qubit gate
@@ -214,7 +221,7 @@ class QrackCircuit:
                 "2x2 matrix 'm' in QrackCircuit.ucmtrx() must contain at least 4 elements."
             )
         Qrack.qrack_lib.qcircuit_append_mc(
-            self.cid, self._complex_byref(m), len(c), self._ulonglong_byref(c), q, p
+            self.cid, QrackCircuit._complex_byref(m), len(c), QrackCircuit._ulonglong_byref(c), q, p
         )
 
     def run(self, qsim):
@@ -248,20 +255,6 @@ class QrackCircuit:
         """
         Qrack.qrack_lib.qcircuit_out_to_file(self.cid, filename.encode("utf-8"))
 
-    def in_from_file(filename):
-        """Read in optimized circuit from file
-
-        Reads in an (optimized) circuit from a file named
-        according to the "filename" parameter.
-
-        Args:
-            filename: Name of file
-        """
-        out = QrackCircuit()
-        Qrack.qrack_lib.qcircuit_in_from_file(out.cid, filename.encode("utf-8"))
-
-        return out
-
     def out_to_string(self):
         """Output optimized circuit to string
 
@@ -273,19 +266,6 @@ class QrackCircuit:
 
         return out.value.decode("utf-8")
 
-    def file_gate_count(filename):
-        """File gate count
-
-        Return the count of gates in a QrackCircuit file
-
-        Args:
-            filename: Name of file
-        """
-        tokens = []
-        with open(filename, "r") as file:
-            tokens = file.read().split()
-        return int(tokens[1])
-
     def to_qiskit_circuit(self):
         """Convert to a Qiskit circuit
 
@@ -302,6 +282,36 @@ class QrackCircuit:
 
         return QrackCircuit.string_to_qiskit_circuit(self.out_to_string())
 
+    @staticmethod
+    def in_from_file(filename):
+        """Read in optimized circuit from file
+
+        Reads in an (optimized) circuit from a file named
+        according to the "filename" parameter.
+
+        Args:
+            filename: Name of file
+        """
+        out = QrackCircuit()
+        Qrack.qrack_lib.qcircuit_in_from_file(out.cid, filename.encode("utf-8"))
+
+        return out
+
+    @staticmethod
+    def file_gate_count(filename):
+        """File gate count
+
+        Return the count of gates in a QrackCircuit file
+
+        Args:
+            filename: Name of file
+        """
+        tokens = []
+        with open(filename, "r") as file:
+            tokens = file.read().split()
+        return int(tokens[1])
+
+    @staticmethod
     def file_to_qiskit_circuit(filename):
         """Convert an output file to a Qiskit circuit
 
@@ -325,6 +335,7 @@ class QrackCircuit:
         with open(filename, "r") as file:
             return QrackCircuit.string_to_qiskit_circuit(file.read())
 
+    @staticmethod
     def string_to_qiskit_circuit(circ_string):
         """Convert an output string to a Qiskit circuit
 
@@ -398,6 +409,7 @@ class QrackCircuit:
 
         return circ
 
+    @staticmethod
     def in_from_qiskit_circuit(circ):
         """Read a Qiskit circuit into a QrackCircuit
 
@@ -443,6 +455,7 @@ class QrackCircuit:
 
         return out
 
+    @staticmethod
     def file_to_quimb_circuit(
         filename,
         circuit_type=QuimbCircuitType.Circuit,
@@ -526,6 +539,7 @@ class QrackCircuit:
 
         return tcirc
 
+    @staticmethod
     def file_to_tensorcircuit(
         filename, inputs=None, circuit_params=None, binding_params=None
     ):
@@ -558,6 +572,7 @@ class QrackCircuit:
             qcirc, qcirc.num_qubits, inputs, circuit_params, binding_params
         )
 
+    @staticmethod
     def in_from_tensorcircuit(tcirc, enable_instruction=False, enable_inputs=False):
         """Convert a TensorCircuit circuit to a QrackCircuit
 

pyqrack/qrack_neuron.py

@@ -64,7 +64,7 @@ class QrackNeuron:
         self.nid = Qrack.qrack_lib.init_qneuron(
             simulator.sid,
             len(controls),
-            self._ulonglong_byref(controls),
+            QrackNeuron._ulonglong_byref(controls),
             target,
             activation_fn,
             alpha,
@@ -99,10 +99,12 @@ class QrackNeuron:
         self._throw_if_error()
         return result
 
-    def _ulonglong_byref(self, a):
+    @staticmethod
+    def _ulonglong_byref(a):
         return (ctypes.c_ulonglong * len(a))(*a)
 
-    def _real1_byref(self, a):
+    @staticmethod
+    def _real1_byref(a):
         # This needs to be c_double, if PyQrack is built with fp64.
         if Qrack.fppow < 6:
             return (ctypes.c_float * len(a))(*a)
@@ -125,7 +127,7 @@ class QrackNeuron:
             raise ValueError(
                 "Angles 'a' in QrackNeuron.set_angles() must contain at least (2 ** len(self.controls)) elements."
             )
-        Qrack.qrack_lib.set_qneuron_angles(self.nid, self._real1_byref(a))
+        Qrack.qrack_lib.set_qneuron_angles(self.nid, QrackNeuron._real1_byref(a))
         self._throw_if_error()
 
     def get_angles(self):
@@ -137,7 +139,7 @@ class QrackNeuron:
         Raises:
             RuntimeError: QrackNeuron C++ library raised an exception.
         """
-        ket = self._real1_byref([0.0] * (1 << len(self.controls)))
+        ket = QrackNeuron._real1_byref([0.0] * (1 << len(self.controls)))
         Qrack.qrack_lib.get_qneuron_angles(self.nid, ket)
         self._throw_if_error()
         return list(ket)
@@ -260,3 +262,89 @@ class QrackNeuron:
         """
         Qrack.qrack_lib.qneuron_learn_permutation(self.nid, eta, e, r)
         self._throw_if_error()
+
+    @staticmethod
+    def quantile_bounds(vec, bits):
+        """ Calculate vector quantile bounds
+
+        This is a static helper method to calculate the quantile
+        bounds of 2 ** bits worth of quantiles.
+
+        Args:
+            vec: numerical vector
+            bits: log2() of quantile count
+
+        Returns:
+            Quantile (n + 1) bounds for n-quantile division, including
+            minimum and maximum values
+        """
+
+        bins = 1 << bits
+        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]]
+
+    @staticmethod
+    def discretize(vec, bounds):
+        """ Discretize vector by quantile bounds
+
+        This is a static helper method to discretize a numerical
+        vector according to quantile bounds calculated by the
+        quantile_bounds(vec, bits) static method.
+
+        Args:
+            vec: numerical vector
+            bounds: (n + 1) n-quantile bounds including extrema
+
+        Returns:
+            Discretized bit-row vector, least-significant first
+        """
+
+        bounds = bounds[1:]
+        bounds_len = len(bounds)
+        bits = bounds_len.bit_length() - 1
+        n = len(vec)
+        vec_discrete = [[False] * n for _ in range(bits)]
+        for i, v in enumerate(vec):
+            p = 0
+            while (p < bounds_len) and (v > bounds[p]):
+                p += 1
+            for b in range(bits):
+                vec_discrete[b][i] = bool((p >> b) & 1)
+
+        return vec_discrete
+
+    @staticmethod
+    def flatten_and_transpose(arr):
+        """ 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
+        feature columns.
+
+        Args:
+            arr: bit-row matrix
+
+        Returns:
+            Observation-row matrix with flat feature columns
+        """
+        return list(zip(*[item for sublist in arr for item in sublist]))
+
+    @staticmethod
+    def bin_endpoints_average(bounds):
+        """ Bin endpoints average
+
+        This is a static helper method that accepts the output
+        bins from quantile_bounds() and returns the average points
+        between the bin endpoints. (This is NOT always necessarily
+        the best heuristic for how to convert binned results back
+        to numerical results, but it is often a reasonable way.)
+
+        Args:
+            bounds: (n + 1) n-quantile bounds including extrema
+
+        Returns:
+            List of average points between the bin endpoints
+        """
+        return [((bounds[i] + bounds[i + 1]) / 2) for i in range(len(bounds) - 1)]