zena-sdk 0.1.4__cp38-abi3-win_amd64.whl

qsys/runtime/execute.py

@@ -0,0 +1,155 @@
+# qsys/runtime/execute.py
+from __future__ import annotations
+from typing import Any, Dict
+
+from qsys.circuit.quantum_circuit import QuantumCircuit
+from qsys.errors import ValidationError
+try:
+    from simulator_statevector import QuantumCircuit as SimulatorCircuit
+except ImportError:
+    # Fallback or error - for now we assume it's there as per request
+    from simulator_statevector import StateVecPy as SimulatorCircuit # This wont work, but prevents import error if structure mismatch.
+    # Actually, let's just import it. If it fails, the user needs to compile.
+    pass
+from simulator_statevector import QuantumCircuit as SimulatorCircuit
+
+# --- helper: try to call the transpiler / pass manager if available --- #
+from importlib import import_module
+
+
+def _maybe_run_transpiler(qc: QuantumCircuit, backend: Any) -> QuantumCircuit:
+    try:
+        transpiler = import_module("qsys.transpiler")
+    except Exception:
+        return qc
+
+    candidates = ("run_pass_manager", "pass_manager", "apply_passes", "transpile")
+    for name in candidates:
+        fn = getattr(transpiler, name, None)
+        if not callable(fn):
+            continue
+        try:
+            return fn(qc, backend=backend)
+        except TypeError:
+            pass
+        try:
+            return fn(qc, backend)
+        except TypeError:
+            pass
+        try:
+            return fn(qc)
+        except Exception:
+            pass
+    return qc
+
+
+def _validate_circuit_indices(circuit: QuantumCircuit) -> None:
+    """
+    Strict runtime validation: ensure all qubit indices are within [0, n_qubits-1]
+    and classical indices are within [0, n_clbits-1].
+    Raises ValidationError with helpful message on the first problem found.
+    """
+    n_q = circuit.n_qubits
+    n_c = circuit.n_clbits
+    for instr in circuit.instructions:
+        # check qubit indices
+        for q in instr.qubits or ():
+            if not isinstance(q, int):
+                raise ValidationError(f"qubit index must be int, got {type(q)}")
+            if q < 0 or q >= n_q:
+                raise ValidationError(f"invalid qubit index {q}")
+        # check classical bits if present (some instr may have clbits)
+        for c in getattr(instr, "clbits", ()) or ():
+            if not isinstance(c, int):
+                raise ValidationError(f"classical bit index must be int, got {type(c)}")
+            if c < 0 or c >= n_c:
+                raise ValidationError(f"invalid classical bit index {c}")
+
+
+def execute(
+    circuit: QuantumCircuit,
+    backend: Any = None,
+    shots: int = 1024,
+    seed: int | None = None,
+    use_transpiler: bool = True,
+) -> Dict[str, Any]:
+    """
+    Execute `circuit` on the local statevector simulator.
+
+    - If use_transpiler is True, attempt to run the transpiler/pass manager.
+    - Validate indices strictly before running (raises ValidationError).
+    - If shots > 0, return sampled counts; if shots == 0 return the statevector.
+    """
+    if backend is not None:
+        print("Warning: backend ignored – using simulator")
+
+    # Optionally run the transpiler first (defensive)
+    if use_transpiler:
+        circuit = _maybe_run_transpiler(circuit, backend)
+
+    # Runtime validation (strict)
+    _validate_circuit_indices(circuit)
+
+    # instantiate simulator circuit
+    sim = SimulatorCircuit(circuit.n_qubits)
+
+    # apply instructions
+    for instr in circuit.instructions:
+        op = instr.name
+        qubits = instr.qubits
+        params = instr.params or []
+
+        if op == "rz":
+            sim.rz(qubits[0], params[0])
+        elif op == "sx":
+            sim.sx(qubits[0])
+        elif op == "x":
+            sim.x(qubits[0])
+        elif op == "y":
+            sim.y(qubits[0])
+        elif op == "z":
+            sim.z(qubits[0])
+        elif op == "h":
+            sim.h(qubits[0])
+        elif op == "s":
+            sim.s(qubits[0])
+        elif op == "sdg":
+            sim.sdg(qubits[0])
+        elif op == "t":
+            sim.t(qubits[0])
+        elif op == "tdg":
+            sim.tdg(qubits[0])
+        elif op == "rx":
+            sim.rx(qubits[0], params[0])
+        elif op == "ry":
+            sim.ry(qubits[0], params[0])
+        elif op == "cx":
+            sim.cx(qubits[0], qubits[1])
+        elif op == "swap":
+            sim.swap(qubits[0], qubits[1])
+        # measures are handled by the run() method implicitly or we ignore them here 
+        # because the rust `run` method just measures all at the end?
+        # WAIT. The Rust `run` method measures ALL qubits.
+        # The Python `QuantumCircuit` has explicit `measure`.
+        # The current `StateVecPy` implementation of `measure_counts` measures ALL qubits into a bitstring.
+        # So it matches the implicit behavior if we ignore specific measure instructions 
+        # (assuming we want full register measurement).
+        # If the user wants partial measurement, the current Rust implementation doesn't support it well yet 
+        # (it returns full n_qubits string).
+        # So we just ignore 'measure' op here and rely on `run` doing full measurement.
+
+    result: Dict[str, Any] = {"shots": shots, "seed": seed}
+    if backend is not None:
+        result["backend_id"] = getattr(backend, "id", "local_sim")
+
+    if shots is not None and shots > 0:
+        counts = sim.run(shots, seed)
+        # ensure a plain dict is returned to tests
+        result["counts"] = dict(counts)
+    else:
+        # return final statevector
+        # sim is SimulatorCircuit (QuantumCircuit). We need to call statevector().
+        sv = sim.statevector()
+        result["statevector"] = sv
+
+    return result

qsys/target.py

@@ -0,0 +1,44 @@
+# qsys/target.py
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import List, Tuple, Dict, Optional
+import json
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Target:
+    n_qubits: int
+    basis_gates: List[str]
+    coupling_map: List[Tuple[int, int]]  # directed edges control → target
+    name: str = ""
+    durations: Optional[Dict[str, float]] = None  # ns, optional
+    error_rates: Optional[Dict[str, float]] = None  # optional
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name or f"{self.n_qubits}q-generic",
+            "n_qubits": self.n_qubits,
+            "basis_gates": self.basis_gates,
+            "coupling_map": self.coupling_map,
+            "durations": self.durations,
+            "error_rates": self.error_rates,
+        }
+
+    def to_json(self, path: str | Path) -> None:
+        Path(path).write_text(json.dumps(self.to_dict(), indent=2))
+
+    @staticmethod
+    def from_json(path: str | Path) -> "Target":
+        data = json.loads(Path(path).read_text())
+        return Target(
+            n_qubits=data["n_qubits"],
+            basis_gates=data["basis_gates"],
+            coupling_map=data["coupling_map"],
+            name=data.get("name", ""),
+            durations=data.get("durations"),
+            error_rates=data.get("error_rates"),
+        )
+
+    def __str__(self) -> str:
+        return f"Target({self.name or 'unnamed'}, {self.n_qubits} qubits, {len(self.coupling_map)} edges)"

qsys/targets.py

@@ -0,0 +1,63 @@
+# qsys/backends.py - FINAL VERSION
+from __future__ import annotations
+
+from .target import Target
+
+
+def line_target(n_qubits: int) -> Target:
+    edges = [(i, i + 1) for i in range(n_qubits - 1)]
+    edges += [(i + 1, i) for i in range(n_qubits - 1)]
+    return Target(
+        n_qubits=n_qubits,
+        name=f"line-{n_qubits}",
+        basis_gates=["rz", "sx", "x", "cx", "measure"],
+        coupling_map=edges,
+    )
+
+
+def ring_target(n_qubits: int) -> Target:
+    edges = [(i, (i + 1) % n_qubits) for i in range(n_qubits)]
+    edges += [((i + 1) % n_qubits, i) for i in range(n_qubits)]
+    return Target(
+        n_qubits=n_qubits,
+        name=f"ring-{n_qubits}",
+        basis_gates=["rz", "sx", "x", "cx", "measure"],
+        coupling_map=edges,
+    )
+
+
+def heavy_hex_target() -> Target:
+    edges = [
+        (0, 1),
+        (1, 0),
+        (1, 2),
+        (2, 1),
+        (2, 3),
+        (3, 2),
+        (3, 4),
+        (4, 3),
+        (4, 5),
+        (5, 4),
+        (5, 6),
+        (6, 5),
+        (0, 6),
+        (6, 0),
+        (1, 6),
+        (6, 1),
+        (3, 5),
+        (5, 3),
+    ]
+    return Target(
+        n_qubits=7,
+        name="heavy-hex-7",
+        basis_gates=["rz", "sx", "x", "cx", "measure"],
+        coupling_map=edges,
+    )
+
+
+BUILTIN_TARGETS = {
+    "line_5": line_target(5),
+    "line_16": line_target(16),
+    "ring_8": ring_target(8),
+    "heavy_hex_7": heavy_hex_target(),
+}

qsys/transpiler/__init__.py

@@ -0,0 +1,6 @@
+# transpiler package
+from .basis import basis_map  # noqa: F401
+from .opt1q import optimize_1q  # noqa: F401
+from .passes import PassConfig, transpile  # noqa: F401
+from .routing import route_on_coupling  # noqa: F401
+from .validate import ValidationReport, validate  # noqa: F401

qsys/transpiler/basis.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import math
+
+from ..backends.base import Backend
+from ..ir.types import Instruction
+
+NATIVE = {"x", "sx", "rz", "cx", "measure"}
+
+
+def basis_map(circuit, backend: Backend):
+    """
+    Return a *new* circuit where non-native ops are decomposed into {x,sx,rz,cx,measure}.
+
+    MVP: decompose 'h' as: sx(q); rz(q, pi/2)
+    Notes:
+    - Decomposition is correct up to a global phase, which does not affect measurement statistics.
+    - Later we can extend with rx/ry etc. using Euler-style decompositions.
+    """
+    from ..circuit.quantum_circuit import QuantumCircuit  # avoid circular import
+
+    out = QuantumCircuit(circuit.n_qubits, getattr(circuit, "n_clbits", 0))
+
+    for inst in circuit.instructions:
+        name = inst.name
+        qs = inst.qubits
+        ps = inst.params
+        cs = inst.clbits
+
+        if name in NATIVE:
+            out._instructions.append(Instruction(name, qs, ps, cs))
+        elif name == "h":
+            q = qs[0]
+            out._instructions.append(Instruction("sx", (q,), ()))
+            out._instructions.append(Instruction("rz", (q,), (math.pi / 2,)))
+        else:
+            # Unknown non-native; keep as-is for now (later phases will expand)
+            out._instructions.append(Instruction(name, qs, ps, cs))
+    return out

qsys/transpiler/opt1q.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import math
+
+from ..ir.types import Instruction
+
+
+def _is_small(angle: float, eps: float) -> bool:
+    """Normalize angle to (-pi, pi] and compare against eps."""
+    a = (angle + math.pi) % (2 * math.pi) - math.pi
+    return abs(a) < eps
+
+
+def optimize_1q(circuit, eps: float = 1e-9):
+    """
+    Peephole optimizations on single-qubit gates (local, order-preserving w.r.t. other qubits):
+      - Merge consecutive RZ on same qubit: RZ(a); RZ(b) -> RZ(a+b); drop if ~0.
+      - Collapse SX·SX -> X on same qubit, exactly.
+      - Cancel X·X -> I (drop both) on same qubit.
+    Scope boundaries: a CX or MEASURE on a qubit ends the local 1q block
+    for that qubit (we do not commute across multi-qubit ops).
+    Returns a NEW circuit.
+    """
+    from ..circuit.quantum_circuit import QuantumCircuit  # avoid circular import
+
+    n = circuit.n_qubits
+    out = QuantumCircuit(n, getattr(circuit, "n_clbits", 0))
+    out_insts: list[Instruction] = out._instructions
+
+    # Track, per qubit, index in out_insts of the last 1q gate affecting that qubit
+    last_idx: list[int | None] = [None] * n
+
+    def bump(q: int, new_pos: int | None):
+        last_idx[q] = new_pos
+
+    for inst in circuit.instructions:
+        name, qs, ps = inst.name, inst.qubits, inst.params
+
+        # Multi-qubit gate or measure: flush context for involved qubits and copy through
+        if name == "cx":
+            out_insts.append(inst)
+            c, t = qs
+            bump(c, None)
+            bump(t, None)
+            continue
+
+        if name == "measure":
+            q = qs[0]
+            out_insts.append(inst)
+            bump(q, None)
+            continue
+
+        # Single-qubit gates we know: x, sx, rz
+        if name not in ("x", "sx", "rz"):
+            # Unknown 1q op: copy and reset its qubit context for safety
+            out_insts.append(inst)
+            bump(qs[0], None)
+            continue
+
+        q = qs[0]
+        li = last_idx[q]
+
+        if name == "rz":
+            theta = float(ps[0])
+            if li is not None and out_insts[li].name == "rz":
+                # Merge angles at last RZ
+                prev = out_insts[li]
+                new_theta = float(prev.params[0]) + theta
+                if _is_small(new_theta, eps):
+                    # Remove previous; current consumed (drop both)
+                    out_insts.pop(li)
+                    bump(q, None)
+                else:
+                    out_insts[li] = Instruction("rz", (q,), (new_theta,), None)
+                # Do not append current
+            else:
+                out_insts.append(inst)
+                bump(q, len(out_insts) - 1)
+            continue
+
+        if name == "sx":
+            if li is not None and out_insts[li].name == "sx":
+                # SX · SX -> X (replace previous SX with X; current consumed)
+                out_insts[li] = Instruction("x", (q,), (), None)
+                # Keep context at this X (may cancel with next X)
+            else:
+                out_insts.append(inst)
+                bump(q, len(out_insts) - 1)
+            continue
+
+        if name == "x":
+            if li is not None and out_insts[li].name == "x":
+                # X · X -> I (drop previous X and consume current)
+                out_insts.pop(li)
+                bump(q, None)
+            else:
+                out_insts.append(inst)
+                bump(q, len(out_insts) - 1)
+            continue
+
+    return out

qsys/transpiler/passes.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..backends.base import Backend
+from ..errors import ValidationError
+from .basis import basis_map
+from .opt1q import optimize_1q
+from .routing import route_on_coupling
+from .validate import validate
+
+
+@dataclass(frozen=True)
+class PassConfig:
+    do_routing: bool = True
+    do_opt1q: bool = True
+    eps: float = 1e-9  # for small-angle pruning in opt1q
+
+
+def transpile(
+    circuit,
+    backend: Backend,
+    config: PassConfig | None = None,
+    return_report: bool = False,
+):
+    """
+    Run the standard pipeline:
+      1) basis_map  -> rewrite non-native gates (e.g., h) to {x,sx,rz,cx,measure}
+      2) validate   -> structure + basis checks; compute 'needs_routing'
+      3) route      -> (optional) insert SWAP chains so CXs follow coupling_map
+      4) optimize_1q-> (optional) peephole: merge RZ; SX·SX→X; X·X cancels
+
+    Returns either the mapped circuit, or (mapped circuit, ValidationReport) if return_report=True.
+    """
+    cfg = config or PassConfig()
+
+    # 1) map to native
+    mapped = basis_map(circuit, backend)
+
+    # 2) validate native circuit
+    report = validate(mapped, backend)
+
+    # 3) routing if required and enabled
+    routed = mapped
+    if cfg.do_routing and report.needs_routing:
+        routed = route_on_coupling(mapped, backend)
+        # Re-validate after routing; should not need routing now
+        report = validate(routed, backend)
+        if report.needs_routing:
+            raise ValidationError("Routing pass did not satisfy coupling constraints.")
+
+    # 4) 1q optimizations
+    optimized = optimize_1q(routed, eps=cfg.eps) if cfg.do_opt1q else routed
+
+    if return_report:
+        return optimized, report
+    return optimized

qsys/transpiler/routing.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from collections import deque
+
+from ..backends.base import Backend
+from ..ir.types import Instruction
+
+
+def _build_graph(edges: list[tuple[int, int]]) -> dict[int, list[int]]:
+    """Undirected adjacency from coupling_map."""
+    g: dict[int, list[int]] = {}
+    for a, b in edges or []:
+        g.setdefault(a, []).append(b)
+        g.setdefault(b, []).append(a)
+    return g
+
+
+def _shortest_path(g: dict[int, list[int]], src: int, dst: int) -> list[int] | None:
+    """BFS shortest path in an undirected graph. Returns list of vertices [src,...,dst]."""
+    if src == dst:
+        return [src]
+    q = deque([src])
+    prev: dict[int, int | None] = {src: None}
+    while q:
+        u = q.popleft()
+        for v in g.get(u, []):
+            if v in prev:
+                continue
+            prev[v] = u
+            if v == dst:
+                # reconstruct
+                path = [dst]
+                while prev[path[-1]] is not None:
+                    path.append(prev[path[-1]])  # type: ignore[index]
+                path.reverse()
+                return path
+            q.append(v)
+    return None
+
+
+def _emit_swap_as_cx_triple(out_insts: list[Instruction], a: int, b: int):
+    """Decompose SWAP(a,b) into 3 CXs on adjacent qubits a-b."""
+    out_insts.append(Instruction("cx", (a, b), ()))
+    out_insts.append(Instruction("cx", (b, a), ()))
+    out_insts.append(Instruction("cx", (a, b), ()))
+
+
+def route_on_coupling(circuit, backend: Backend):
+    """
+    Route CXs so they respect backend.target.coupling_map by inserting SWAP chains.
+    Strategy: maintain a logical->physical mapping; 1q gates follow the mapping;
+    when a CX(log_c,log_t) isn't on an edge, move the *control's physical* toward target
+    along a shortest path with SWAPs (no swap-back). Update mapping as we swap.
+
+    Returns a NEW circuit with only native ops (cx, rz, sx, x, measure),
+    whose CXs are all between adjacent qubits per coupling_map.
+    """
+    from ..circuit.quantum_circuit import QuantumCircuit  # avoid circular import
+
+    tgt = backend.target
+    g = _build_graph(tgt.coupling_map)
+    n = circuit.n_qubits
+
+    # Start with identity layout: logical i at physical i
+    # loc[logical] = physical; which_log[physical] = logical
+    loc = list(range(n))
+    which_log = list(range(n))
+
+    out = QuantumCircuit(n, getattr(circuit, "n_clbits", 0))
+    out_insts: list[Instruction] = out._instructions  # alias
+
+    for inst in circuit.instructions:
+        name, qs, ps, cs = inst.name, inst.qubits, inst.params, inst.clbits
+
+        if name in ("x", "sx", "rz"):
+            q = qs[0]
+            out_insts.append(Instruction(name, (loc[q],), ps, cs))
+            continue
+
+        if name == "measure":
+            q = qs[0]
+            out_insts.append(Instruction("measure", (loc[q],), ps, cs))
+            continue
+
+        if name == "cx":
+            c_log, t_log = qs
+            c_phy, t_phy = loc[c_log], loc[t_log]
+
+            # If directly connected, emit and continue
+            if (c_phy, t_phy) in tgt.coupling_map or (t_phy, c_phy) in tgt.coupling_map:
+                out_insts.append(Instruction("cx", (c_phy, t_phy), ()))
+                continue
+
+            # Otherwise, find path and move control toward target with SWAPs
+            path = _shortest_path(g, c_phy, t_phy)
+            if not path or len(path) < 2:
+                raise ValueError(
+                    f"No path between qubits {c_phy} and {t_phy} for routing"
+                )
+
+            # Walk path by swapping control forward one hop at a time (record hops)
+            current = c_phy
+            hops: list[tuple[int, int]] = []
+            for next_hop in path[1:-1]:  # stop one before t_phy
+                _emit_swap_as_cx_triple(out_insts, current, next_hop)
+                # Update mapping
+                l_a = which_log[current]
+                l_b = which_log[next_hop]
+                which_log[current], which_log[next_hop] = l_b, l_a
+                loc[l_a], loc[l_b] = next_hop, current
+                hops.append((current, next_hop))
+                current = next_hop
+
+            # Now control is adjacent to target; emit CX with current (control) -> t_phy
+            c_phy = current
+            if not (
+                (c_phy, t_phy) in tgt.coupling_map or (t_phy, c_phy) in tgt.coupling_map
+            ):
+                raise ValueError("Routing logic error: not adjacent after swaps")
+            out_insts.append(Instruction("cx", (c_phy, t_phy), ()))
+
+            # Swap BACK along the reverse path to restore the original logical->physical layout
+            for a, b in reversed(hops):
+                _emit_swap_as_cx_triple(out_insts, a, b)
+                # Undo the mapping change
+                l_a = which_log[a]
+                l_b = which_log[b]
+                which_log[a], which_log[b] = l_b, l_a
+                loc[l_a], loc[l_b] = b, a
+
+            continue
+
+        # Anything else: copy as-is (basis_map should have eliminated non-native)
+        out_insts.append(inst)
+
+    return out