qoptct 0.3.0__py3-none-any.whl

qoptct/__init__.py

@@ -0,0 +1,28 @@
+"""qoptct -- a verified Clifford+T circuit optimizer (T count and CX count). Project name: qopt.
+
+The distribution and the import package are called ``qoptct`` (the name ``qopt`` on PyPI belongs to an
+unrelated project):  ``pip install qoptct``  /  ``import qoptct``.
+
+Command line:  qoptct optimize INPUT.qc [-o OUT] [--mode cx|balanced|t] [--clean] [--meas] [--net] [--post] ...
+Python:        import qoptct; names, ref, best, how = qoptct.optimize("circuit.qc")
+Qiskit:        from qoptct.qiskit_qopt import QoptPass
+               transpile(qc, optimization_method="qoptct")   # transpiler stage plugin
+
+PyTorch is optional and only needed for the neural mode (``--net``):  pip install "qoptct[net]".
+
+Internal modules use flat imports (``import evo_lib``) and ``import qoptct`` for the core functions; the package
+directory is therefore put on sys.path when qoptct is imported, and the public names of ``qoptct.qopt_core``
+(load_qc, save_qc, prove, optimize, ... and the time limits PROG_SEC, PROVE_SEC, FOLD_SEC, PYZX_SEC) are
+re-exported here. Caches go to $QOPT_CACHE (default ~/.cache/qopt).
+"""
+import os as _os
+import sys as _sys
+
+__version__ = "0.3.0"
+_PKG = _os.path.dirname(_os.path.abspath(__file__))
+if _PKG not in _sys.path:
+    _sys.path.insert(0, _PKG)
+
+from . import qopt_core as _core  # noqa: E402
+
+globals().update({k: v for k, v in vars(_core).items() if not k.startswith("__") and k not in ("_os", "_sys")})

qoptct/bench_real.py

@@ -0,0 +1,212 @@
+"""Этап 12, пункт 2+3 плана автора: реальные алгоритмы (набор Feynman/Amy–Maslov–Mosca, Clifford+T).
+Сравнение CX и времени: исходная, Qiskit opt3, PyZX full_optimize, наш блочный (с сетью / без сети),
+и наш блочный поверх результата PyZX. Проверка равенства — PyZX verify_equality (+ Operator для n<=10)."""
+import glob, json, os, sys, time, warnings
+from multiprocessing import Pool
+from pathlib import Path
+import numpy as np
+warnings.filterwarnings("ignore")
+ROOT = Path(__file__).resolve().parent
+sys.setrecursionlimit(100000)
+RESTARTS = int(os.environ.get("RESTARTS", "0")); SKIP_P = float(os.environ.get("SKIP_P", "0.15"))
+VARIANTS = os.environ.get("VARIANTS", "ours,nonet,pz")
+OUT = os.environ.get("OUT", "bench_real")
+KS = (5, 4, 3) if os.environ.get("MODEL5") else (4, 3)
+
+
+def zx_to_ours(c):
+    out = []
+    for g in c.to_basic_gates().gates:
+        nm = type(g).__name__
+        if nm == "HAD": out.append(("h", (g.target,)))
+        elif nm == "NOT": out.append(("x", (g.target,)))
+        elif nm == "CNOT": out.append(("cx", (g.control, g.target)))
+        elif nm == "CZ": out += [("h", (g.target,)), ("cx", (g.control, g.target)), ("h", (g.target,))]
+        elif nm in ("T", "S", "Z", "ZPhase"):
+            if abs(float(g.phase) * 4 - round(float(g.phase) * 4)) > 1e-9:
+                raise ValueError("фаза не кратна pi/4")
+            k = int(round(float(g.phase) * 4)) % 8  # фаза в единицах pi/4
+            seq = {0: [], 1: ["t"], 2: ["s"], 3: ["s", "t"], 4: ["s", "s"], 5: ["sdg", "tdg"], 6: ["sdg"], 7: ["tdg"]}[k]
+            out += [(s, (g.target,)) for s in seq]
+        elif nm == "XPhase":
+            k = int(round(float(g.phase) * 4)) % 8
+            seq = {0: [], 1: ["t"], 2: ["s"], 3: ["s", "t"], 4: ["s", "s"], 5: ["sdg", "tdg"], 6: ["sdg"], 7: ["tdg"]}[k]
+            out += [("h", (g.target,))] + [(s, (g.target,)) for s in seq] + [("h", (g.target,))]
+        else:
+            raise ValueError("команда " + nm)
+    return out
+
+
+def ours_to_zx(c, n):
+    import pyzx as zx
+    z = zx.Circuit(n)
+    for nm, qb in c:
+        if nm == "h": z.add_gate("HAD", qb[0])
+        elif nm == "x": z.add_gate("NOT", qb[0])
+        elif nm == "cx": z.add_gate("CNOT", qb[0], qb[1])
+        elif nm in ("t", "tdg"): z.add_gate("T", qb[0], adjoint=(nm == "tdg"))
+        elif nm in ("s", "sdg"): z.add_gate("S", qb[0], adjoint=(nm == "sdg"))
+    return z
+
+
+def check(c1, c0, n):
+    """Сквозная проверка: n<=10 — матрицы целиком; n<=22 — 3 случайных состояния (с общей фазой);
+    больше — 'blocks' (каждый заменённый блок уже проверен точно при замене)."""
+    from qiskit.quantum_info import Operator, Statevector, random_statevector
+    import block_synth as bs
+    if n <= 10:
+        return bool(Operator(bs.to_qc(c1, n)).equiv(Operator(bs.to_qc(c0, n))))
+    if n > 22:  # PyZX: True — доказано; False/неудача — НЕ доказано (None), а не «верно»
+        try:
+            r = ours_to_zx(c1, n).verify_equality(ours_to_zx(c0, n))
+        except Exception:
+            r = False
+        if r:
+            return True
+        if n <= 26:  # PyZX не доказал — численно (complex128, 2 случайных состояния, общая фаза), как у агента
+            sys.path.insert(0, str(ROOT / "proto2")); from verify import numeric_equal
+            return True if numeric_equal(c1, c0, n) else False
+        return None
+    q1, q0 = bs.to_qc(c1, n), bs.to_qc(c0, n)
+    ph = None
+    for seed in range(3):
+        v = random_statevector(2 ** n, seed=seed)
+        o = np.vdot(v.evolve(q0).data, v.evolve(q1).data)
+        if abs(abs(o) - 1) > 1e-11 or (ph is not None and abs(o - ph) > 1e-11):  # Г1: 1e-6 пропускал ошибки при n=20–22
+            return False
+        ph = o
+    return True
+
+
+def cx(c):
+    return sum(g[0] == "cx" for g in c)
+
+
+def _init(model4):
+    import block_synth as bs
+    bs._init(64, 256, model4, False, 0.5, False)
+
+
+def job(args):
+    """PORTFOLIO=1: несколько нарезок (без/с перестановками, разные зерна), берётся лучшая — нарезка неустойчива."""
+    name, n, circ, no_net, cycles = args
+    if not os.environ.get("PORTFOLIO"):
+        return job1(args, 0)
+    t0 = time.time(); best = None
+    import block_synth as _bs
+    _bs.CACHE.clear(); os.environ["KEEP_CACHE"] = "1"
+    variants = ((False, 0), (True, 0), (False, 1)) if RESTARTS else ((False, 0), (True, 0))
+    for commute, seed in variants:
+        if commute: os.environ["COMMUTE"] = "1"
+        else: os.environ.pop("COMMUTE", None)
+        r = job1(args, seed)
+        if best is None or r[3] and __import__("block_synth").key(r[3]) < __import__("block_synth").key(best[3]):
+            best = r
+    os.environ.pop("COMMUTE", None); os.environ.pop("KEEP_CACHE", None)
+    return best[0], best[1], best[2], best[3], time.time() - t0
+
+
+def job1(args, seed):
+    name, n, circ, no_net, cycles = args
+    import block_synth as bs
+    bs.W["no_net"] = no_net
+    if not os.environ.get("KEEP_CACHE"): bs.CACHE.clear()  # память только внутри схемы — результат не зависит от порядка схем по процессам (шум ±25)
+    t0 = time.time(); best = circ
+    GC = bool(os.environ.get("GCANCEL"))
+    if GC:
+        from global_cancel import global_cancel
+        if os.environ.get("RTOF"):  # свёртка фаз по всей схеме (агент «нестандартные идеи»)
+            sys.path.insert(0, str(ROOT / "proto2")); from phase_fold import fold_cancel
+            _gc = global_cancel
+            global_cancel = lambda c: _gc(fold_cancel(c, n))
+        best = global_cancel(best)
+    for _ in range(cycles):
+        improved = False
+        if GC:
+            c2 = global_cancel(best)
+            if bs.key(c2) < bs.key(best):
+                best, improved = c2, True
+        for k in KS:
+            for flip in (0, 1):
+                c = bs.inv_circ(best) if flip else best
+                c2 = bs.one_pass(c, min(k, n))
+                c2 = bs.inv_circ(c2) if flip else c2
+                if bs.key(c2) < bs.key(best):
+                    best, improved = c2, True
+        if not improved:
+            break
+    rng = np.random.default_rng(seed); fails = 0
+    while fails < RESTARTS:  # случайные перезапуски нарезки, пока RESTARTS подряд без выигрыша
+        k = KS[int(rng.integers(len(KS)))]; flip = int(rng.integers(2))
+        c = bs.inv_circ(best) if flip else best
+        c2 = bs.one_pass(c, min(k, n), rng, SKIP_P)
+        c2 = bs.inv_circ(c2) if flip else c2
+        if bs.key(c2) < bs.key(best):
+            best, fails = c2, 0
+        else:
+            fails += 1
+    return name, no_net, len(circ), best, time.time() - t0
+
+
+def main():
+    import pyzx as zx
+    from qiskit import QuantumCircuit, transpile
+    model4 = sys.argv[1] if len(sys.argv) > 1 else ""
+    rows, jobs, base = {}, [], {}
+    for f in sorted(glob.glob(str(ROOT / "bench_qc" / "*.qc"))):
+        name = os.path.basename(f)[:-3]
+        if os.environ.get("ONLY") and name not in os.environ["ONLY"].split(","): continue
+        z = zx.Circuit.load(f).to_basic_gates(); n = z.qubits
+        orig = zx_to_ours(z)
+        t = time.time(); zo = zx.optimize.full_optimize(z.copy()); tz = time.time() - t
+        pz = zx_to_ours(zo)
+        qc = QuantumCircuit(n)
+        for nm, qb in orig: getattr(qc, nm)(*qb)
+        t = time.time(); qcx = transpile(qc, basis_gates=["u", "cx"], optimization_level=3, seed_transpiler=0).count_ops().get("cx", 0); tq = time.time() - t
+        base[name] = {"n": n, "orig": cx(orig), "qiskit": qcx, "t_qiskit": tq, "pyzx": cx(pz), "t_pyzx": tz, "z": z, "orig_c": orig}
+        V = VARIANTS.split(",")
+        jobs += ([(name, n, orig, False, 4)] if "ours" in V else []) + ([(name, n, orig, True, 4)] if "nonet" in V else []) \
+            + ([(name + "+pz", n, pz, False, 4)] if "pz" in V else [])
+        ep = ROOT / "results" / ("evo_starts_local.json" if os.environ.get("EVO_STARTS") == "local" else "evo_starts.json")
+        if os.environ.get("EVO") and ep.exists():
+            _evo = json.loads(ep.read_text())
+            if name in _evo:
+                ev = [(g, tuple(q)) for g, q in _evo[name]]
+                base[name]["evo_start"] = cx(ev)
+                jobs.append((name + "+evo", n, ev, False, 4))
+        rp = ROOT / "proto2" / f"combo2_{name}.pkl"
+        if os.environ.get("RTOF") and rp.exists():
+            import pickle
+            _n, _raw, rt = pickle.load(open(rp, "rb"))
+            base[name]["rt_start"] = cx(rt)
+            jobs.append((name + "+rt", n, rt, False, 4))
+        print(f"{name}: n={n} CX {cx(orig)} | Qiskit {qcx} ({tq:.1f} с) | PyZX {cx(pz)} ({tz:.1f} с)", flush=True)
+    jobs.sort(key=lambda j: -len(j[2]))
+    with Pool(8, initializer=_init, initargs=(model4,)) as pool:
+        for name, no_net, ln, best, sec in pool.imap_unordered(job, jobs):
+            b = name.replace("+pz", "").replace("+rt", "").replace("+evo", "")
+            ok = check(best, base[b]["orig_c"], base[b]["n"])
+            key = "pz_ours" if name.endswith("+pz") else ("rt_ours" if name.endswith("+rt") else ("evo_ours" if name.endswith("+evo") else ("nonet" if no_net else "ours")))
+            base[b][key], base[b]["t_" + key], base[b]["ok_" + key] = cx(best), sec, ok
+            base[b]["circ_" + key] = [[g, list(q)] for g, q in best]  # сохранить схему для перепроверки
+            print(f"  {name} {'без сети' if no_net else 'с сетью'}: CX {cx(best)} за {sec:.0f} с, проверка {ok}", flush=True)
+    out = {k: {kk: vv for kk, vv in v.items() if kk not in ("z", "orig_c")} for k, v in base.items()}
+    (ROOT / "results" / f"{OUT}.json").write_text(json.dumps(out, indent=1))
+    print("ИТОГ таблица:", flush=True)
+    print("схема n | исх | Qiskit | PyZX | наш(сеть) | наш(без сети) | PyZX+наш | время наш/без/Qiskit/PyZX | проверка", flush=True)
+    for k, v in out.items():
+        print(f"{k} {v['n']} | {v['orig']} | {v['qiskit']} | {v['pyzx']} | {v.get('ours')} | {v.get('nonet')} | {v.get('pz_ours')} | "
+              f"{v.get('t_ours',0):.0f}/{v.get('t_nonet',0):.0f}/{v['t_qiskit']:.1f}/{v['t_pyzx']:.1f} | "
+              f"{v.get('ok_ours')}/{v.get('ok_nonet')}/{v.get('ok_pz_ours')}", flush=True)
+    tot = lambda key: sum(v.get(key, 0) or 0 for v in out.values())
+    for v in out.values():  # лучшее из проверенных стартов
+        cands = [v[k] for k in ("ours", "rt_ours", "evo_ours") if v.get(k) is not None and v.get("ok_" + k) is True]
+        v["best_ours"] = min(cands) if cands else None
+    print("СУММА лучшего из стартов (только проверенные):", tot("best_ours"),
+          "| rt-старт с сетью:", tot("rt_ours"), "| без проверки:", [k for k, v in out.items() if v["best_ours"] is None], flush=True)
+    (ROOT / "results" / f"{OUT}.json").write_text(json.dumps(out, indent=1))
+    print(f"СУММА CX: наш {tot('ours')}, Qiskit {tot('qiskit')}, исходные {tot('orig')}; время наш {tot('t_ours'):.0f} с", flush=True)
+
+
+if __name__ == "__main__":
+    main()

qoptct/block_synth.py

@@ -0,0 +1,265 @@
+"""Этап 11: блочный синтез. Схему на n кубитах режем на блоки по <=k (4/3) кубитов,
+каждый блок пересобирают обученные агенты синтеза 2q/3q/4q (exp/u_k_best), берём, если CX меньше.
+Проходы повторяются (k=4, k=3, и на обращённой схеме — другие границы блоков), пока есть выигрыш.
+Итог проверяется точным сравнением матриц (Qiskit Operator.equiv)."""
+import argparse, json, os, time, warnings
+from multiprocessing import Pool
+from pathlib import Path
+import numpy as np
+torch = None  # optional; imported lazily by _torch() -- only neural block resynthesis (--net) needs it
+
+
+def _torch():
+    """Import torch on first use (pip install "qoptct[net]"); the other modes never import it."""
+    global torch
+    if torch is None:
+        import qoptct
+        qoptct.require_torch()
+        import torch as _t
+        torch = _t
+    return torch
+
+
+warnings.filterwarnings("ignore")
+ROOT = Path(__file__).resolve().parent
+INV = {"h": "h", "x": "x", "s": "sdg", "sdg": "s", "t": "tdg", "tdg": "t", "cx": "cx"}
+CTX = {}
+CACHE = {}
+W = {}
+
+
+def _init(width, widen, model4='', no_net=False, opt_time=0.5, uniform=False):
+    _torch()
+    import qgnn
+    from qfast import ChoiEngine
+    torch.set_num_threads(1)
+    W["w"], W["widen"], W["no_net"], W["opt"], W["uniform"] = width, widen, no_net, opt_time, uniform
+    for k in (2, 3, 4) + ((5,) if os.environ.get("MODEL5") else ()):
+        mp = {4: model4, 3: os.environ.get("MODEL3", ""), 5: os.environ.get("MODEL5", "")}.get(k, "")
+        ck = torch.load((ROOT / mp) if mp else (ROOT / "models" / f"u_{k}_best_{k}q.pt"), map_location="cpu", weights_only=False)
+        net = {"gnnu": qgnn.QGNNU, "gnnh": qgnn.QGNNH, "gnnhp": qgnn.QGNNHP}[ck.get("arch", "gnnu")](**ck["gnn_kw"])
+        net.load_state_dict(ck["state_dict"]); net.eval()
+        eng = ChoiEngine(k)
+        cfg = {"beta": 3.0, "gamma": 0.0, "max_steps": ck["max_steps"], "extra": 3, "task": "unitary"}
+        val = None
+        vp = ROOT / "models" / f"value_u{k}q.pt"
+        if vp.exists():
+            vck = torch.load(vp, map_location="cpu", weights_only=False)
+            val = qgnn.QValueU(**vck["kw"]); val.load_state_dict(vck["state_dict"]); val.eval(); cfg["lam"] = 0.5
+        gi = {(nm, tuple(qb)): i for i, (nm, qb) in enumerate(eng.gates)}
+        CTX[k] = (net, eng, cfg, val, gi)
+
+
+def key(c):
+    return (sum(g[0] == "cx" for g in c), len(c))
+
+
+def inv_circ(c):
+    return [(INV[nm], qb) for nm, qb in reversed(c)]
+
+
+DIAG = {"s", "sdg", "t", "tdg"}
+
+
+def commutes(g1, g2):
+    """Точные правила перестановки команд Clifford+T (И4): диагональные — через управляющий CX, X — через цель,
+    CX с общими только управляющими или только целевыми кубитами."""
+    (n1, q1), (n2, q2) = g1, g2
+    if not set(q1) & set(q2):
+        return True
+    if n1 != "cx" and n2 != "cx":
+        return (n1 in DIAG and n2 in DIAG) or (n1 == n2 == "x") or (n1 == n2 == "h")
+    if n1 == "cx" and n2 == "cx":
+        return q1[0] != q2[1] and q2[0] != q1[1]
+    one, cx = (g1, g2) if n2 == "cx" else (g2, g1)
+    return (one[0] in DIAG and one[1][0] == cx[1][0]) or (one[0] == "x" and one[1][0] == cx[1][1])
+
+
+def take_block_commute(rem, k, rng=None, p=0.0):
+    """Как take_block, но команда может «перепрыгнуть» пропущенные, если коммутирует со всеми пропущенными на своих кубитах."""
+    Q, take, skip = set(), [], []
+    for g in rem:
+        qs = set(g[1])
+        if rng is not None and Q and rng.random() < p:
+            skip.append(g); continue
+        if len(Q | qs) <= k and all(commutes(g, s) for s in skip if set(s[1]) & qs):
+            take.append(g); Q |= qs
+        else:
+            skip.append(g)
+    return sorted(Q), take, skip
+
+
+def take_block(rem, k, rng=None, p=0.0):
+    if os.environ.get("COMMUTE"):
+        return take_block_commute(rem, k, rng, p)
+    Q, B, take, skip = set(), set(), [], []
+    for g in rem:
+        qs = set(g[1])
+        if rng is not None and Q and rng.random() < p:  # случайный пропуск — другие границы блоков
+            skip.append(g); B |= qs; continue
+        if not (qs & B) and len(Q | qs) <= k:
+            take.append(g); Q |= qs
+        else:
+            skip.append(g); B |= qs
+    return sorted(Q), take, skip
+
+
+def resynth(qs, gates):
+    import ei2
+    from circuit_opt import optimize
+    k = len(qs)
+    if k < 2 or not any(g[0] == "cx" for g in gates):
+        return gates
+    net, eng, cfg, val, gi = CTX[k]
+    m = {q: i for i, q in enumerate(qs)}
+    prog = [gi[(nm, tuple(m[q] for q in qb))] for nm, qb in gates]
+    target = eng.choi(prog)
+    from qfast import state_sig
+    sig = (k, state_sig(target))
+    if W.get("use_cache", True) and sig in CACHE:  # память: этот блок уже решали
+        W["hits"] = W.get("hits", 0) + 1
+        best = CACHE[sig]
+        return [(eng.gates[eng.inverse_action[a]][0], tuple(qs[i] for i in eng.gates[eng.inverse_action[a]][1]))
+                for a in reversed(best)]
+    raw = [eng.inverse_action[a] for a in reversed(prog)]  # известная размотка (точная)
+    best = optimize(eng, target, raw, time_limit=W["opt"])
+    if not exact(eng, target, best):
+        best = raw
+    ei2._net, ei2._eng, ei2._cfg, ei2._val = net, eng, cfg, val
+    if W.get("uniform"):  # перебор без сети: равные вероятности всех команд, без оценщика
+        ei2._net, ei2._val = Uniform(eng.n_actions), None
+    for w in (() if W["no_net"] else (W["w"], W["widen"])):
+        if not w:
+            continue
+        res = ei2.beam(target, w, bound=len(best))
+        if res is not None:
+            acts = optimize(eng, target, res[1], time_limit=1.0)
+            if exact(eng, target, acts) and key([eng.gates[a] for a in acts]) < key([eng.gates[a] for a in best]):
+                best = acts
+            break
+    CACHE[sig] = list(best)
+    return [(eng.gates[eng.inverse_action[a]][0], tuple(qs[i] for i in eng.gates[eng.inverse_action[a]][1]))
+            for a in reversed(best)]
+
+
+def Uniform(na):
+    """Network stand-in with equal probabilities for all actions (search without a network)."""
+    t = _torch()
+
+    class _Uniform(t.nn.Module):
+        def __init__(self, na):
+            super().__init__(); self.na = na
+
+        def forward(self, x):
+            return t.zeros(x.shape[0], self.na)
+
+    return _Uniform(na)
+
+
+def exact(eng, target, acts):
+    """Точная проверка блока: размотка должна дать тождество (совпадение 1 с точностью 1e-9), а не >= 0,99."""
+    s = target
+    for a in acts:
+        s = eng.apply1(s, a)
+    return abs(eng.amp0(s)) ** 2 >= 1 - 1e-9
+
+
+def one_pass(circ, k, rng=None, p=0.0):
+    rem, out = circ, []
+    while rem:
+        qs, take, rem = take_block(rem, k, rng, p)
+        out += resynth(qs, take)
+    return out
+
+
+def to_qc(c, n):
+    from qiskit import QuantumCircuit
+    qc = QuantumCircuit(n)
+    for nm, qb in c:
+        getattr(qc, nm)(*qb)
+    return qc
+
+
+def solve(args):
+    idx, n, circ, max_cycles = args
+    from qiskit.quantum_info import Operator
+    t0 = time.time()
+    best = circ
+    for _ in range(max_cycles):
+        improved = False
+        for k in (4, 3):
+            for flip in (0, 1):
+                c = inv_circ(best) if flip else best
+                c2 = one_pass(c, min(k, n))
+                c2 = inv_circ(c2) if flip else c2
+                if key(c2) < key(best):
+                    best, improved = c2, True
+        if not improved:
+            break
+    ok = Operator(to_qc(best, n)).equiv(Operator(to_qc(circ, n)))
+    return idx, {"cx": key(best)[0], "len": len(best), "equiv": bool(ok), "sec": time.time() - t0, "circ": best}
+
+
+def gen(n, count, seed0=9_000_000):
+    from qiskit import transpile
+    from qfast import Engine, ChoiEngine
+    eng = Engine(n)
+    ce = ChoiEngine(n) if n <= 5 else None
+    one = [i for i, (nm, _) in enumerate(eng.gates) if nm != "cx"]
+    cxs = [i for i, (nm, _) in enumerate(eng.gates) if nm == "cx"]
+    out, seed = [], seed0
+    while len(out) < count:
+        rng = np.random.default_rng(seed); seed += 1
+        prog = []
+        for _ in range(int(rng.integers(n, 4 * n + 1))):
+            for _ in range(int(rng.integers(1, n + 1))):
+                prog.append(int(rng.choice(one)))
+            prog.append(int(rng.choice(cxs)))
+        if ce is not None and abs(ce.amp0(ce.choi(prog))) ** 2 >= 0.99:
+            continue
+        c = [(eng.gates[a][0], tuple(eng.gates[a][1])) for a in prog]
+        qcx = transpile(to_qc(c, n), basis_gates=["u", "cx"], optimization_level=3,
+                        seed_transpiler=0).count_ops().get("cx", 0)
+        if qcx == 0:
+            continue
+        out.append((c, qcx))
+    return out
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--qubits", type=int, default=5)
+    p.add_argument("--count", type=int, default=300)
+    p.add_argument("--width", type=int, default=64)
+    p.add_argument("--widen", type=int, default=0)
+    p.add_argument("--cycles", type=int, default=3)
+    p.add_argument("--workers", type=int, default=8)
+    p.add_argument("--model4", default="")
+    p.add_argument("--no-net", action="store_true")
+    p.add_argument("--uniform", action="store_true", help="тот же поиск, но без сети (равные вероятности)")
+    p.add_argument("--opt-time", type=float, default=0.5)
+    p.add_argument("--tag", default="")
+    a = p.parse_args()
+    n = a.qubits
+    t0 = time.time()
+    data = gen(n, a.count)
+    print(f"{n}q: {len(data)} схем, CX в исходной {np.mean([key(c)[0] for c, _ in data]):.1f}, "
+          f"Qiskit opt3 {np.mean([q for _, q in data]):.1f} ({time.time()-t0:.0f} с)", flush=True)
+    with Pool(a.workers, initializer=_init, initargs=(a.width, a.widen, a.model4, a.no_net, a.opt_time, a.uniform)) as pool:
+        res = dict(pool.imap_unordered(solve, [(i, n, c, a.cycles) for i, (c, _) in enumerate(data)]))
+    orig = np.array([key(c)[0] for c, _ in data]); qk = np.array([q for _, q in data])
+    ours = np.array([res[i]["cx"] for i in range(len(data))])
+    eq = np.mean([res[i]["equiv"] for i in range(len(data))])
+    out = {"uniform": a.uniform, "tag": a.tag, "no_net": a.no_net, "opt_time": a.opt_time, "model4": a.model4, "qubits": n, "count": len(data), "width": a.width, "widen": a.widen, "orig_cx": orig.mean(),
+           "qiskit_opt3_cx": qk.mean(), "block_cx": ours.mean(), "equiv": eq,
+           "better_than_qiskit": float(np.mean(ours < qk)), "equal": float(np.mean(ours == qk)),
+           "worse": float(np.mean(ours > qk)), "minutes": (time.time() - t0) / 60,
+           "sec_per_circuit": float(np.mean([res[i]["sec"] for i in range(len(data))]))}
+    print("ИТОГ:", json.dumps(out), flush=True)
+    (ROOT / "results").mkdir(exist_ok=True)
+    (ROOT / "results" / f"block{a.tag}_{n}q.json").write_text(json.dumps(
+        {"summary": out, "circuits": [{"orig": data[i][0], "qiskit_cx": int(data[i][1]), **res[i]} for i in range(len(data))]}))
+
+
+if __name__ == "__main__":
+    main()

qoptct/circuit_opt.py

@@ -0,0 +1,127 @@
+"""Оптимизатор небольших схем: чистит найденные решения перед тем, как они попадут в учебник.
+
+Решение хранится как список ходов, которые «разматывают» цель обратно в |0...0>.
+Каждое изменение проверяется ТОЧНО: прогоняем цель через новый список ходов на быстром
+моторе qfast и требуем, чтобы вероятность |0...0> осталась >= 0.99. Цель улучшения:
+меньше CX, при равенстве — короче.
+
+Проходы (повторяются, пока что-то улучшается; 2б — удаление пары «CX + любая команда»):
+  1. удаление одной команды (убирает «мусор»: отменяющие друг друга пары после сдвига,
+     фазовые команды на кубитах, где они ничего не меняют, и т.п.);
+  2. удаление двух соседних команд;
+  3. замена окна из 2–3 команд одной командой (например, T,T -> S).
+Проверка: .venv/bin/python circuit_opt.py --qubits 6   (на учебнике, без записи)
+"""
+
+import argparse
+import json
+import time
+
+import numpy as np
+
+SUCCESS = 0.99
+
+
+def _ok(eng, state, actions):
+    s = state
+    for a in actions:
+        s = eng.apply1(s, a)
+    from qfast import amp0
+    import numpy as _np
+    s = _np.asarray(s, complex)
+    return abs(amp0(eng, s)) ** 2 / _np.vdot(s, s).real >= 1 - 1e-6  # точно (Г1 Н3), а не >= 0,99
+
+
+def _key(eng, actions):
+    return (int(eng.is_cx[actions].sum()) if actions else 0, len(actions))
+
+
+def optimize(eng, target, actions, max_passes=4, time_limit=2.0):
+    """Возвращает улучшенный список ходов (или исходный). Всегда проверено точно."""
+    target = np.asarray(target, complex)
+    best = list(actions)
+    if not _ok(eng, target, best):
+        return best
+    t0 = time.time()
+    n_act = eng.n_actions
+    for _ in range(max_passes):
+        improved = False
+        # 1) и 2): удаление одной или двух соседних команд
+        for width in (1, 2):
+            i = 0
+            while i + width <= len(best):
+                cand = best[:i] + best[i + width:]
+                if _ok(eng, target, cand):
+                    best = cand; improved = True
+                else:
+                    i += 1
+                if time.time() - t0 > time_limit:
+                    return best
+        # 2б) удаление любой пары команд, где первая — CX (например, две CX, разделённые
+        #     командами, которые с ними коммутируют) — главный источник экономии CX
+        cx_pos = [i for i, a in enumerate(best) if eng.is_cx[a]]
+        found = False
+        for i in cx_pos:
+            for j in range(len(best)):
+                if j == i:
+                    continue
+                cand = [a for k, a in enumerate(best) if k not in (i, j)]
+                if _ok(eng, target, cand):
+                    best = cand; improved = found = True
+                    break
+            if found or time.time() - t0 > time_limit:
+                break
+        # 3) замена окна из 2–3 команд одной командой (с проверкой, что стало лучше)
+        for width in (2, 3):
+            i = 0
+            while i + width <= len(best):
+                window_key = _key(eng, best[i:i + width])
+                pre = target
+                for a in best[:i]:
+                    pre = eng.apply1(pre, a)
+                done = False
+                for r in range(n_act):
+                    if (int(eng.is_cx[r]), 1) >= window_key:
+                        continue
+                    cand = best[:i] + [r] + best[i + width:]
+                    if _ok(eng, pre, [r] + best[i + width:]):
+                        best = cand; improved = done = True
+                        break
+                if not done:
+                    i += 1
+                if time.time() - t0 > time_limit:
+                    return best
+        if not improved:
+            break
+    return best
+
+
+def main():
+    from qfast import Engine
+    p = argparse.ArgumentParser()
+    p.add_argument("--qubits", type=int, default=6)
+    p.add_argument("--solutions", default=None)
+    p.add_argument("--limit", type=int, default=300)
+    a = p.parse_args()
+    n = a.qubits
+    eng = Engine(n)
+    T = np.load(f"data/train_{n}q.npz")["targets"]
+    sol = json.loads(open(a.solutions or f"data/ei_solutions_{n}q.json").read())
+    keys = list(sol)[:a.limit]
+    cx0 = l0 = cx1 = l1 = better = 0
+    t = time.time()
+    for k in keys:
+        acts = sol[k][1]
+        new = optimize(eng, T[int(k)], acts)
+        assert _ok(eng, np.asarray(T[int(k)], complex), new)
+        c0, c1 = _key(eng, acts), _key(eng, new)
+        cx0 += c0[0]; l0 += c0[1]; cx1 += c1[0]; l1 += c1[1]
+        better += c1 < c0
+    m = len(keys)
+    print(f"{n} кубитов, {m} решений учебника: CX {cx0 / m:.2f} -> {cx1 / m:.2f}, "
+          f"длина {l0 / m:.1f} -> {l1 / m:.1f}; улучшено {better} ({better / m:.0%}); "
+          f"{(time.time() - t) / m * 1000:.0f} мс на решение")
+
+
+if __name__ == "__main__":
+    main()

qoptct/contrib/c1/best_clean/MANIFEST.json

@@ -0,0 +1,13 @@
+{
+ "csla_mux_3": "9d52e8a719c86b757b13c4bd0001c6e69be4afb16acfb773ce8b4428957d2d5d",
+ "gf2^4_mult": "1f0b3f6637d1d73d0c6e69030e77198ed89b9111aa0a5334458084f97e5fce33",
+ "gf2^5_mult": "6ae44de8a94f4998dfb44bf33330cd0106b9f508e63f205ab7b49e8905a21e0a",
+ "mod5_4": "9d32b6df9264366676c3e259211d43c8686b7b3cbcb215e0bfa9d81c3919b3a6",
+ "mod_mult_55": "6740ed207932ae523291aaca0f0d38e5a0fbe903abd10871b2b1923fbbb4b92c",
+ "mod_red_21": "de0573cbb25fbca8b9546e485627901a9fd4135cc2ddfb59abc0e288f29f6656",
+ "rc_adder_6": "337176687452af345b8c078bbe63fe91a8306451c603fe9e627dc4a9395df70b",
+ "tof_10": "8958838674a8025346f3eed2219497c61039f012beef7ec22c4afcfd72980ae0",
+ "tof_3": "10caf87ef6ab65b8f798fa002fa4e2ebb5b44d1e3f2c95a21540121a9613ba7d",
+ "tof_4": "5778913a5c34ef226c9496f0fb8bb772b119b7c3455b31a83492e16913fd85f4",
+ "tof_5": "fde7a805c93176d6db2d2eb93d9aa1f81d58b6537c62ec5f4c37e27a4d25977f"
+}