pyqrack-cpu-complex128 2.22.3__tar.gz → 2.23.0__tar.gz

{pyqrack_cpu_complex128-2.22.3/pyqrack_cpu_complex128.egg-info → pyqrack_cpu_complex128-2.23.0}/PKG-INFO

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

{pyqrack_cpu_complex128-2.22.3 → pyqrack_cpu_complex128-2.23.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)
@@ -1713,16 +1722,68 @@ class QrackAceBackend:
                 else:
                     bits = [self.force_m(a, False) for a in ancs]
 
-                is_flipped = False
-                best_p = -1.0
+                # Map each participant to the SPECIFIC physical replica
+                # of hq1 its own syndrome actually covers -- anc1 is
+                # patch A (hq1[0]), anc1c is always the crossbar
+                # (hq1[2], by construction), and anc1b is whichever of
+                # hq1's replicas lives in hq2's own patch (found by sim
+                # id rather than assumed to be a fixed index, since
+                # corner qubits have patch replicas at indices 1, 3, and
+                # 4). This can legitimately be absent: hq1 and hq2 may
+                # share no common patch at all for an arbitrary (non-
+                # adjacent) logical coupling -- confirmed directly
+                # (hq1=[(2,1),(3,0),(4,2)] coupled to hq2=[(1,1)], no
+                # overlap) -- in which case there is no single physical
+                # replica to target for that participant specifically.
+                replicas = [hq1[0]]
+                if anc1b is not None:
+                    replicas.append(next((r for r in hq1 if r[0] == hq2[0][0]), None))
+                if anc1c is not None:
+                    replicas.append(hq1[2])
+
+                # Majority vote decides whether the LOGICAL value itself
+                # genuinely flipped (updating the LHV shadow, same as the
+                # transversal self.x(lq1) used to do unconditionally);
+                # any minority participant is still individually
+                # corrected below regardless, since ITS replica is wrong
+                # either way -- it just isn't treated as evidence the
+                # logical value moved, the same way a repetition code's
+                # decoded value doesn't change just because one physical
+                # bit needed fixing.
+                n_flipped = sum(1 for b in bits if b)
+                if (n_flipped << 1) > len(ancs):
+                    is_flipped = True
+                    lhv = self._lhv.get(lq1)
+                    if lhv is not None:
+                        lhv.x()
+
                 for i, a in enumerate(ancs):
                     if bits[i]:
                         self.x(a)
-                        if probs[i] > best_p:
-                            best_p = probs[i]
-                if best_p >= 0.0:
-                    self.x(lq1)
-                    is_flipped = True
+                        # Targeted, single-replica correction rather than
+                        # a transversal self.x(lq1): these replicas are a
+                        # pseudo-repetition code for lq1, and a
+                        # participant flipping means THAT PHYSICAL COPY
+                        # is the one in error, not the logical value as a
+                        # whole. Flipping every replica transversally is
+                        # only ever correct by coincidence when all
+                        # participants agree -- on a genuine minority
+                        # disagreement it would "fix" the actual error
+                        # while simultaneously breaking the (correct)
+                        # majority replicas that were never wrong. Fixing
+                        # per-replica is correct in the agreeing case too
+                        # (each flipped participant's own replica still
+                        # gets corrected), so this applies unconditionally,
+                        # not just when a disagreement is detected. Falls
+                        # back to the transversal correction only when no
+                        # single hq1 replica corresponds to this
+                        # participant at all (see the no-overlap case
+                        # above).
+                        b = replicas[i]
+                        if b is not None:
+                            self.sim[b[0]].x(b[1])
+                        else:
+                            self.x(lq1)
             else:
                 anc_sim, anc_idx = self._qubits[anc1][0]
                 p = self.sim[anc_sim].prob(anc_idx)
@@ -1918,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)
@@ -2383,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":
@@ -2627,7 +2828,13 @@ class QrackAceBackend:
             "cx",
             "cy",
             "cz",
+            "ccx",
+            "ccz",
+            "mcx",
+            "mcy",
+            "mcz",
             "swap",
+            "cswap",
             "iswap",
             "reset",
             "measure",
@@ -2670,6 +2877,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.3 → pyqrack_cpu_complex128-2.23.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":
@@ -4568,7 +4570,11 @@ class QrackSimulator:
             "csx",
             "ccx",
             "ccz",
+            "mcx",
+            "mcy",
+            "mcz",
             "swap",
+            "cswap",
             "iswap",
             "cswap",
             "reset",

{pyqrack_cpu_complex128-2.22.3 → pyqrack_cpu_complex128-2.23.0/pyqrack_cpu_complex128.egg-info}/PKG-INFO

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

{pyqrack_cpu_complex128-2.22.3 → pyqrack_cpu_complex128-2.23.0}/setup.py

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