pyqrack-cpu 1.44.1__py3-none-manylinux_2_39_x86_64.whl → 1.44.2__py3-none-manylinux_2_39_x86_64.whl

pyqrack/qrack_ace_backend.py

@@ -11,6 +11,15 @@ from .qrack_simulator import QrackSimulator
 from .pauli import Pauli
 
 
+_IS_QISKIT_AVAILABLE = True
+try:
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+    from qiskit.compiler import transpile
+    from qiskit.quantum_info.operators.symplectic.clifford import Clifford
+except ImportError:
+    _IS_QISKIT_AVAILABLE = False
+
+
 class QrackAceBackend:
     """A back end for elided quantum error correction
 
@@ -28,8 +37,9 @@ class QrackAceBackend:
     def __init__(
         self,
         qubit_count=-1,
+        toClone=None
     ):
-        self.sim = QrackSimulator(3 * qubit_count)
+        self.sim = toClone.sim.clone() if toClone else QrackSimulator(3 * qubit_count)
 
 
     def _ct_pair_prob(self, q1, q2):
@@ -107,6 +117,13 @@ class QrackAceBackend:
         self._encode(hq)
 
 
+    def r(self, p, th, lq):
+        hq = self._unpack(lq)
+        self._decode(hq)
+        self.sim.r(p, th, hq[0])
+        self._encode(hq)
+
+
     def s(self, lq):
         hq = self._unpack(lq)
         self._decode(hq)
@@ -285,3 +302,301 @@ class QrackAceBackend:
 
         return results
 
+
+    def _apply_op(self, operation):
+        name = operation.name
+
+        if (name == 'id') or (name == 'barrier'):
+            # Skip measurement logic
+            return
+
+        conditional = getattr(operation, 'conditional', None)
+        if isinstance(conditional, int):
+            conditional_bit_set = (self._classical_register >> conditional) & 1
+            if not conditional_bit_set:
+                return
+        elif conditional is not None:
+            mask = int(conditional.mask, 16)
+            if mask > 0:
+                value = self._classical_memory & mask
+                while (mask & 0x1) == 0:
+                    mask >>= 1
+                    value >>= 1
+                if value != int(conditional.val, 16):
+                    return
+
+        if (name == 'u1') or (name == 'p'):
+            self._sim.u(0, 0, float(operation.params[0]), operation.qubits[0]._index)
+        elif name == 'u2':
+            self._sim.u(
+                math.pi / 2,
+                float(operation.params[0]),
+                float(operation.params[1]),
+                operation.qubits[0]._index
+            )
+        elif (name == 'u3') or (name == 'u'):
+            self._sim.u(
+                float(operation.params[0]),
+                float(operation.params[1]),
+                float(operation.params[2]),
+                operation.qubits[0]._index
+            )
+        elif name == 'r':
+            self._sim.u(
+                float(operation.params[0]),
+                float(operation.params[1]) - math.pi / 2,
+                (-1 * float(operation.params[1])) + math.pi / 2,
+                operation.qubits[0]._index
+            )
+        elif name == 'rx':
+            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)
+        elif name == 'rz':
+            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':
+            self._sim.x(operation.qubits[0]._index)
+        elif name == 'y':
+            self._sim.y(operation.qubits[0]._index)
+        elif name == 'z':
+            self._sim.z(operation.qubits[0]._index)
+        elif name == 's':
+            self._sim.s(operation.qubits[0]._index)
+        elif name == 'sdg':
+            self._sim.adjs(operation.qubits[0]._index)
+        elif name == 't':
+            self._sim.t(operation.qubits[0]._index)
+        elif name == 'tdg':
+            self._sim.adjt(operation.qubits[0]._index)
+        elif name == 'cx':
+            self._sim.cx(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'cy':
+            self._sim.cy(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'cz':
+            self._sim.cz(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'dcx':
+            self._sim.mcx(operation.qubits[0]._index, operation.qubits[1]._index)
+            self._sim.mcx(operation.qubits[1]._index, operation.qubits[0]._index)
+        elif name == 'swap':
+            self._sim.swap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'iswap':
+            self._sim.iswap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'iswap_dg':
+            self._sim.adjiswap(operation.qubits[0]._index, operation.qubits[1]._index)
+        elif name == 'reset':
+            qubits = operation.qubits
+            for qubit in qubits:
+                if self._sim.m(qubit._index):
+                    self._sim.x(qubit._index)
+        elif name == 'measure':
+            qubits = operation.qubits
+            clbits = operation.clbits
+            cregbits = (
+                operation.register
+                if hasattr(operation, 'register')
+                else len(operation.qubits) * [-1]
+            )
+
+            self._sample_qubits += qubits
+            self._sample_clbits += clbits
+            self._sample_cregbits += cregbits
+
+            if not self._sample_measure:
+                for index in range(len(qubits)):
+                    qubit_outcome = self._sim.m(qubits[index]._index)
+
+                    clbit = clbits[index]
+                    clmask = 1 << clbit
+                    self._classical_memory = (self._classical_memory & (~clmask)) | (
+                        qubit_outcome << clbit
+                    )
+
+                    cregbit = cregbits[index]
+                    if cregbit < 0:
+                        cregbit = clbit
+
+                    regbit = 1 << cregbit
+                    self._classical_register = (
+                        self._classical_register & (~regbit)
+                    ) | (qubit_outcome << cregbit)
+
+        elif name == 'bfunc':
+            mask = int(operation.mask, 16)
+            relation = operation.relation
+            val = int(operation.val, 16)
+
+            cregbit = operation.register
+            cmembit = operation.memory if hasattr(operation, 'memory') else None
+
+            compared = (self._classical_register & mask) - val
+
+            if relation == '==':
+                outcome = compared == 0
+            elif relation == '!=':
+                outcome = compared != 0
+            elif relation == '<':
+                outcome = compared < 0
+            elif relation == '<=':
+                outcome = compared <= 0
+            elif relation == '>':
+                outcome = compared > 0
+            elif relation == '>=':
+                outcome = compared >= 0
+            else:
+                raise QrackError('Invalid boolean function relation.')
+
+            # Store outcome in register and optionally memory slot
+            regbit = 1 << cregbit
+            self._classical_register = (self._classical_register & (~regbit)) | (
+                int(outcome) << cregbit
+            )
+            if cmembit is not None:
+                membit = 1 << cmembit
+                self._classical_memory = (self._classical_memory & (~membit)) | (
+                    int(outcome) << cmembit
+                )
+        else:
+            err_msg = 'QrackAceBackend encountered unrecognized operation "{0}"'
+            raise RuntimeError(err_msg.format(operation))
+
+    def _add_sample_measure(self, sample_qubits, sample_clbits, num_samples):
+        """Generate data samples from current statevector.
+
+        Taken almost straight from the terra source code.
+
+        Args:
+            measure_params (list): List of (qubit, clbit) values for
+                                   measure instructions to sample.
+            num_samples (int): The number of data samples to generate.
+
+        Returns:
+            list: A list of data values in hex format.
+        """
+        # Get unique qubits that are actually measured
+        measure_qubit = [qubit for qubit in sample_qubits]
+        measure_clbit = [clbit for clbit in sample_clbits]
+
+        # Sample and convert to bit-strings
+        if num_samples == 1:
+            sample = self._sim.m_all()
+            result = 0
+            for index in range(len(measure_qubit)):
+                qubit = measure_qubit[index]._index
+                qubit_outcome = (sample >> qubit) & 1
+                result |= qubit_outcome << index
+            measure_results = [result]
+        else:
+            measure_results = self._sim.measure_shots([q._index for q in measure_qubit], num_samples)
+
+        data = []
+        for sample in measure_results:
+            for index in range(len(measure_qubit)):
+                qubit_outcome = (sample >> index) & 1
+                clbit = measure_clbit[index]._index
+                clmask = 1 << clbit
+                self._classical_memory = (self._classical_memory & (~clmask)) | (
+                    qubit_outcome << clbit
+                )
+
+            data.append(bin(self._classical_memory)[2:].zfill(self.num_qubits()))
+
+        return data
+
+    def run_qiskit_circuit(self, experiment, shots=1):
+        if not _IS_QISKIT_AVAILABLE:
+            raise RuntimeError(
+                "Before trying to run_qiskit_circuit() with QrackAceBackend, you must install Qiskit!"
+            )
+
+        instructions = []
+        if isinstance(experiment, QuantumCircuit):
+            instructions = experiment.data
+        else:
+            raise RuntimeError('Unrecognized "run_input" argument specified for run().')
+
+        self._shots = shots
+        self._sample_qubits = []
+        self._sample_clbits = []
+        self._sample_cregbits = []
+        self._sample_measure = True
+        _data = []
+        shotLoopMax = 1
+
+        is_initializing = True
+        boundary_start = -1
+
+        for opcount in range(len(instructions)):
+            operation = instructions[opcount]
+
+            if operation.name == 'id' or operation.name == 'barrier':
+                continue
+
+            if is_initializing and (
+                (operation.name == 'measure') or (operation.name == 'reset')
+            ):
+                continue
+
+            is_initializing = False
+
+            if (operation.name == 'measure') or (operation.name == 'reset'):
+                if boundary_start == -1:
+                    boundary_start = opcount
+
+            if (boundary_start != -1) and (operation.name != 'measure'):
+                shotsPerLoop = 1
+                shotLoopMax = self._shots
+                self._sample_measure = False
+                break
+
+        preamble_memory = 0
+        preamble_register = 0
+        preamble_sim = None
+
+        if self._sample_measure or boundary_start <= 0:
+            boundary_start = 0
+            self._sample_measure = True
+            shotsPerLoop = self._shots
+            shotLoopMax = 1
+        else:
+            boundary_start -= 1
+            if boundary_start > 0:
+                self._sim = self
+                self._classical_memory = 0
+                self._classical_register = 0
+
+                for operation in instructions[:boundary_start]:
+                    self._apply_op(operation)
+
+                preamble_memory = self._classical_memory
+                preamble_register = self._classical_register
+                preamble_sim = self._sim
+
+        for shot in range(shotLoopMax):
+            if preamble_sim is None:
+                self._sim = self
+                self._classical_memory = 0
+                self._classical_register = 0
+            else:
+                self._sim = QrackAceBackend(toClone=preamble_sim)
+                self._classical_memory = preamble_memory
+                self._classical_register = preamble_register
+
+            for operation in instructions[boundary_start:]:
+                self._apply_op(operation)
+
+            if not self._sample_measure and (len(self._sample_qubits) > 0):
+                _data += [bin(self._classical_memory)[2:].zfill(self.num_qubits())]
+                self._sample_qubits = []
+                self._sample_clbits = []
+                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
+            )
+
+        del self._sim
+
+        return _data

pyqrack/qrack_simulator.py

@@ -3843,7 +3843,7 @@ class QrackSimulator:
 
             if not self._sample_measure:
                 for index in range(len(qubits)):
-                    qubit_outcome = self._sim.m(qubits[index])
+                    qubit_outcome = self._sim.m(qubits[index]._index)
 
                     clbit = clbits[index]
                     clmask = 1 << clbit

{pyqrack_cpu-1.44.1.dist-info → pyqrack_cpu-1.44.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cpu
-Version: 1.44.1
+Version: 1.44.2
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano

{pyqrack_cpu-1.44.1.dist-info → pyqrack_cpu-1.44.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
 pyqrack/__init__.py,sha256=yH4CMEDLk59IphSl9303zTP8Pmj3usIQMSDCOb42KCc,768
 pyqrack/neuron_activation_fn.py,sha256=NYG78IFCiJ586E9oA6lJl38Rl18_WFfcdL6I2NYfiPs,594
 pyqrack/pauli.py,sha256=wg500wDOwdIU4lEVJoMmjtbAdmtakZYzLPjdzC2rwUQ,654
-pyqrack/qrack_ace_backend.py,sha256=tyky2zZDKI4BfoepbV5cffQquftO96P8CTRldALc78Q,6783
+pyqrack/qrack_ace_backend.py,sha256=p1h3c6pHU3OqPmF2Ak6zx06v6tYd3e-1C2GzSJ56ve4,18549
 pyqrack/qrack_circuit.py,sha256=TyppOMNk_0nolChMRewf4CfQGuYiEUJ8qUWWN6y03PE,19093
 pyqrack/qrack_neuron.py,sha256=oEvMnkFFOUBXFbIXYYY-Nir3yTo0nyw_xoRdNXeSEgk,8843
 pyqrack/qrack_neuron_torch_layer.py,sha256=Xn6MF1hSLT0bFequx4AJTsxFdg3gO01WB9rmDE7sP9w,5824
-pyqrack/qrack_simulator.py,sha256=6nMSg0vQwBg9syuu9lhCpBcB0x-CAD-XNA9zc53mcQY,135707
+pyqrack/qrack_simulator.py,sha256=KeLEW49mkifX0C0caux9l3HHcF73YF6iewTBqWzv0Go,135714
 pyqrack/qrack_stabilizer.py,sha256=CJhj8GLPH-ZM38joHr9ZL-6_IY2JC8Zql7COoePJC0U,2129
 pyqrack/quimb_circuit_type.py,sha256=Sk-Tmn38kUYmAkJJ75btWuhYZyTXOOezmowFhfdiGDc,621
 pyqrack/qrack_system/__init__.py,sha256=-oZ9dsb1hixsnrkUJRY_C5DzQ_l6MtifF_Z465BgqV4,334
@@ -15,8 +15,8 @@ pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.so.9.19.1,sha256=jGH5FdZqL24sYRJ
 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=OjY0I8PGbellrRfdIyiC0RLdpdbbJex3C2D_bapNIqE,2211
-pyqrack_cpu-1.44.1.dist-info/licenses/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
-pyqrack_cpu-1.44.1.dist-info/METADATA,sha256=v5iGcCQ7LHmAq0WuRfeS8qDxXj2V0VOMk4PxBzKnOi4,6702
-pyqrack_cpu-1.44.1.dist-info/WHEEL,sha256=doDm-6Syt8k_BJ5JAagnRBCT6Lp00BS6WvJ8r832rUs,109
-pyqrack_cpu-1.44.1.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
-pyqrack_cpu-1.44.1.dist-info/RECORD,,
+pyqrack_cpu-1.44.2.dist-info/licenses/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
+pyqrack_cpu-1.44.2.dist-info/METADATA,sha256=H2hNU0OSd2BZcdxHYINynTZYteEV5hg0JysX_JZN5s0,6702
+pyqrack_cpu-1.44.2.dist-info/WHEEL,sha256=doDm-6Syt8k_BJ5JAagnRBCT6Lp00BS6WvJ8r832rUs,109
+pyqrack_cpu-1.44.2.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
+pyqrack_cpu-1.44.2.dist-info/RECORD,,