pyqrack-cpu-complex128 2.22.4__tar.gz → 2.24.0__tar.gz

{pyqrack_cpu_complex128-2.22.4/pyqrack_cpu_complex128.egg-info → pyqrack_cpu_complex128-2.24.0}/PKG-INFO

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

{pyqrack_cpu_complex128-2.22.4 → pyqrack_cpu_complex128-2.24.0}/pyqrack/qrack_ace_backend.py

@@ -18,6 +18,17 @@ try:
     from qiskit.circuit.quantumcircuit import QuantumCircuit
     from qiskit.compiler import transpile
     from qiskit.quantum_info.operators.symplectic.clifford import Clifford
+    from qiskit.transpiler import Target, InstructionProperties
+    from qiskit.circuit import Parameter
+    from qiskit.circuit.library import (
+        IGate, UGate, U3Gate, U2Gate, U1Gate,
+        XGate, YGate, ZGate, HGate,
+        RXGate, RYGate, RZGate,
+        SGate, SdgGate, TGate, TdgGate,
+        CXGate, CYGate, CZGate, SwapGate, iSwapGate,
+        CCXGate, CCZGate, CSwapGate,
+        Measure, Reset,
+    )
 except ImportError:
     _IS_QISKIT_AVAILABLE = False
 
@@ -803,7 +814,6 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11], q)
 
-    @staticmethod
     def _get_lhv_bloch_angles(sim):
         z = sim.bloch[2]
         x = sim.bloch[0]
@@ -812,7 +822,6 @@ class QrackAceBackend:
         azimuth = math.atan2(y, x)
         return azimuth, inclination
 
-    @staticmethod
     def _rotate_lhv_to_bloch(sim, delta_azimuth, delta_inclination):
         cosA = math.cos(delta_azimuth)
         sinA = math.sin(delta_azimuth)
@@ -1741,7 +1750,6 @@ class QrackAceBackend:
                 # logical value moved, the same way a repetition code's
                 # decoded value doesn't change just because one physical
                 # bit needed fixing.
-                is_flipped = False
                 n_flipped = sum(1 for b in bits if b)
                 if (n_flipped << 1) > len(ancs):
                     is_flipped = True
@@ -1971,46 +1979,174 @@ class QrackAceBackend:
             self._cpauli(lq1, lq2, True, Pauli.PauliZ)
 
     def mcx(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.cx(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcx() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.cx(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.mcx() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].mcx(c, t)
 
     def mcy(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.cy(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcy() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.cy(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.mcy() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].mcy(c, t)
 
     def mcz(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.cz(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcz() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.cz(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.mcz() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].mcz(c, t)
 
     def macx(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.acx(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macx() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.acx(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.macx() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].macx(c, t)
 
     def macy(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.acy(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macy() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.acy(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.macy() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].macy(c, t)
 
     def macz(self, lq1, lq2):
-        if len(lq1) > 1:
+        if len(lq1) == 1:
+            self.acz(lq1[0], lq2)
+            return
+
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macz() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self.acz(lq1[0], lq2)
+        s = hq[0][0]
+        t = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.macz() is provided for syntax convenience and only supports 1 control qubit!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].macz(c, t)
+
+    def cswap(self, lq1, lq2, lq3):
+        hq = self._unpack(lq2)
+        if len(hq) > 1:
+            raise RuntimeError(
+                "QrackAceBackend.cswap() is provided for syntax convenience and only supports intra-patch!"
+            )
+        s = hq[0][0]
+        t1 = hq[0][1]
+        hq = self._unpack(lq3)
+        if (len(hq) > 1) or (s != hq[0][0]):
+            raise RuntimeError(
+                "QrackAceBackend.cswap() is provided for syntax convenience and only supports intra-patch!"
+            )
+        t2 = hq[0][1]
+        c = []
+        for l in lq1:
+            hq = self._unpack(l)
+            if (len(hq) > 1) or (s != hq[0][0]):
+                raise RuntimeError(
+                    "QrackAceBackend.cswap() is provided for syntax convenience and only supports intra-patch!"
+                )
+            c.append(hq[0][1])
+
+        # We happen to be able to accommodate this:
+        self.sim[s].cswap(c, t1, t2)
 
     def swap(self, lq1, lq2):
         hq1 = self._unpack(lq1)
@@ -2436,11 +2572,23 @@ class QrackAceBackend:
             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 == "ccx":
+            self._sim.mcx([operation.qubits[0]._index, operation.qubits[1]._index], operation.qubits[2]._index)
+        elif name == "ccz":
+            self._sim.mcz([operation.qubits[0]._index, operation.qubits[1]._index], operation.qubits[2]._index)
+        elif name == "mcx":
+            self._sim.mcx([q._index for q in operation.qubits[:-1]], operation.qubits[-1]._index)
+        elif name == "mcy":
+            self._sim.mcy([q._index for q in operation.qubits[:-1]], operation.qubits[-1]._index)
+        elif name == "mcz":
+            self._sim.mcz([q._index for q in operation.qubits[:-1]], 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 == "cswap":
+            self._sim.cswap([q._index for q in operation.qubits[:-2]], operation.qubits[-2]._index, operation.qubits[-1]._index)
         elif name == "iswap":
             self._sim.iswap(operation.qubits[0]._index, operation.qubits[1]._index)
         elif name == "iswap_dg":
@@ -2680,7 +2828,10 @@ class QrackAceBackend:
             "cx",
             "cy",
             "cz",
+            "ccx",
+            "ccz",
             "swap",
+            "cswap",
             "iswap",
             "reset",
             "measure",
@@ -2723,6 +2874,149 @@ class QrackAceBackend:
 
         return self._coupling_map
 
+    # Moved here from AceQasmSimulator (qiskit-qrack-provider), so a
+    # QrackAceBackend can be transpiled against directly with plain Qiskit,
+    # without needing the separate Qiskit BackendV2 wrapper at all. The
+    # Qiskit backend now calls this instead of duplicating the logic.
+    #
+    # One correction made in the move: the original 1-qubit "boundary
+    # penalty hint" set was approximated from get_logical_coupling_map()
+    # (any qubit appearing in ANY coupling pair) -- but that map includes
+    # ordinary bulk-bulk pairs within the same patch too, so it actually
+    # flagged nearly every qubit as "boundary." Here, with direct access to
+    # self._unpack(), the real criterion (len(self._unpack(q)) > 1) is used
+    # instead.
+    def get_target(self, description=None, error_2q=0.5):
+        """Build a qiskit Target describing this backend's gate set and
+        connectivity, so it can be used with qiskit.transpile() directly --
+        with or without the separate Qiskit BackendV2 wrapper.
+
+        IMPORTANT, verified directly rather than assumed: qiskit's
+        transpile() does NOT reliably enforce the qubit-tuple-level
+        InstructionProperties restrictions declared here for 3+-qubit gates
+        (ccx/ccz/cswap), at any optimization_level that doesn't outright
+        crash. Confirmed: the default optimization_level raises
+        TranspilerError("target contains multi-qubit operations") on ANY
+        Target containing 3+-qubit gates, valid placement or not (Qiskit's
+        default SabreLayout routing pass doesn't support them at all).
+        optimization_level=0 or 1 avoid that crash, but ALSO transpiled a
+        deliberately-invalid (boundary-qubit) ccx placement successfully in
+        testing -- i.e., they don't validate 3-qubit placements against the
+        target either, they just don't crash on them.
+        The Target's 3-qubit entries are still meaningful as a description
+        of what's actually valid (useful for introspection, or for a
+        transpiler pass that does check placements properly), but they are
+        NOT currently a transpile-time safety guarantee the way the 2-qubit
+        coupling map is. The actual, reliable enforcement is the runtime
+        RuntimeError in mcx()/mcy()/mcz()/cswap() themselves, which fire
+        correctly regardless of what the transpiler allowed through.
+        """
+        if not _IS_QISKIT_AVAILABLE:
+            raise RuntimeError(
+                "QrackAceBackend.get_target() requires Qiskit to be installed!"
+            )
+
+        n = self.num_qubits()
+        tgt = Target(num_qubits=n, description=description)
+
+        # Parameters for parameterised gates
+        theta = Parameter("theta")
+        phi = Parameter("phi")
+        lam = Parameter("lam")
+
+        # --- single-qubit gates: all qubits ---
+        boundary = {q for q in range(n) if len(self._unpack(q)) > 1}
+
+        def _1q_props():
+            return {
+                (q,): InstructionProperties()
+                for q in range(n)
+            }
+
+        tgt.add_instruction(IGate(), _1q_props())
+        tgt.add_instruction(UGate(theta, phi, lam), _1q_props())
+        tgt.add_instruction(U3Gate(theta, phi, lam), _1q_props())
+        tgt.add_instruction(U2Gate(phi, lam), _1q_props())
+        tgt.add_instruction(U1Gate(lam), _1q_props())
+        tgt.add_instruction(RXGate(theta), _1q_props())
+        tgt.add_instruction(RYGate(theta), _1q_props())
+        tgt.add_instruction(RZGate(theta), _1q_props())
+        tgt.add_instruction(HGate(), _1q_props())
+        tgt.add_instruction(XGate(), _1q_props())
+        tgt.add_instruction(YGate(), _1q_props())
+        tgt.add_instruction(ZGate(), _1q_props())
+        tgt.add_instruction(SGate(), _1q_props())
+        tgt.add_instruction(SdgGate(), _1q_props())
+        tgt.add_instruction(TGate(), _1q_props())
+        tgt.add_instruction(TdgGate(), _1q_props())
+
+        # --- two-qubit gates: coupled pairs (includes boundary-crossing
+        # pairs -- those are supported, via the noisy-coupler mechanism) ---
+        bulk = []
+        for q in range(n):
+            hq = self._unpack(q)
+            if len(hq) == 1:
+                bulk.append(q)
+        coupling_map = self.get_logical_coupling_map()
+        if coupling_map:
+            pair_props = {
+                (a, b): InstructionProperties() if (a in bulk) and (b in bulk) else InstructionProperties(error=error_2q) for a, b in coupling_map
+            }
+        else:
+            pair_props = {
+                (a, b): InstructionProperties()
+                for a in range(n)
+                for b in range(n)
+                if a != b
+            }
+
+        tgt.add_instruction(CXGate(), pair_props)
+        tgt.add_instruction(CYGate(), pair_props)
+        tgt.add_instruction(CZGate(), pair_props)
+        tgt.add_instruction(SwapGate(), pair_props)
+        tgt.add_instruction(iSwapGate(), pair_props)
+
+        # --- 3-qubit gates: intra-patch, all-bulk triples only ---
+        # ccx/ccz/cswap (and, by extension, mcx/mcy/mcz beyond a single
+        # control) are only valid when every involved qubit is bulk and
+        # shares the same patch -- see mcx()/cswap() above, which raise
+        # otherwise.
+        #
+        # CCXGate/CCZGate and CSwapGate do NOT share a qubit-ordering
+        # convention (verified directly against their gate definitions):
+        # CCXGate puts its target on qubit index 2, with 0-1 as the two
+        # (interchangeable) controls; CSwapGate puts its control on qubit
+        # index 0, with 1-2 as the (interchangeable) swapped pair. They
+        # need separately-ordered InstructionProperties dicts.
+        bulk_by_patch = {}
+        for q in range(n):
+            hq = self._unpack(q)
+            if len(hq) == 1:
+                bulk_by_patch.setdefault(hq[0][0], []).append(q)
+
+        ccx_props = {}
+        cswap_props = {}
+        for qubits_here in bulk_by_patch.values():
+            for pivot in qubits_here:
+                others = [q for q in qubits_here if q != pivot]
+                for i in range(len(others)):
+                    for j in range(len(others)):
+                        if i == j:
+                            continue
+                        ccx_props[(others[i], others[j], pivot)] = InstructionProperties()
+                        cswap_props[(pivot, others[i], others[j])] = InstructionProperties()
+        if ccx_props:
+            tgt.add_instruction(CCXGate(), ccx_props)
+            tgt.add_instruction(CCZGate(), ccx_props)
+        if cswap_props:
+            tgt.add_instruction(CSwapGate(), cswap_props)
+
+        # --- measure / reset: all qubits ---
+        tgt.add_instruction(Measure(), {(q,): InstructionProperties() for q in range(n)})
+        tgt.add_instruction(Reset(), {(q,): InstructionProperties() for q in range(n)})
+
+        return tgt
+
     # Designed by Dan, Elara (ChatGPT), and (Anthropic) Claude:
     def create_noise_model(self, x=0.5, y=0.5):
         if not _IS_QISKIT_AER_AVAILABLE:

{pyqrack_cpu_complex128-2.22.4 → pyqrack_cpu_complex128-2.24.0}/pyqrack/qrack_simulator.py

@@ -4311,6 +4311,8 @@ class QrackSimulator:
             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 == "cswap":
+            self._sim.cswap([q._index for q in operation.qubits[:-2]], operation.qubits[-2]._index, operation.qubits[-1]._index)
         elif name == "iswap":
             self._sim.iswap(operation.qubits[0]._index, operation.qubits[1]._index)
         elif name == "iswap_dg":
@@ -4569,6 +4571,7 @@ class QrackSimulator:
             "ccx",
             "ccz",
             "swap",
+            "cswap",
             "iswap",
             "cswap",
             "reset",

{pyqrack_cpu_complex128-2.22.4 → pyqrack_cpu_complex128-2.24.0/pyqrack_cpu_complex128.egg-info}/PKG-INFO

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

{pyqrack_cpu_complex128-2.22.4 → pyqrack_cpu_complex128-2.24.0}/setup.py

@@ -7,7 +7,7 @@ from setuptools import setup
 from setuptools.command.build_py import build_py
 
 
-VERSION = "2.22.4"
+VERSION = "2.24.0"
 
 # Read long description from README.
 README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')