westquant 0.1.0a1__tar.gz

westquant-0.1.0a1/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: westquant
+Version: 0.1.0a1
+Summary: WestQuant Open — Search the representation, not just the parameters
+Author: WestQuant Open / David Vesterlund
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/WestQuantOpen
+Project-URL: Source, https://github.com/WestQuantOpen/westquant
+Project-URL: Documentation, https://github.com/WestQuantOpen/westquant#readme
+Keywords: quantum,compilation,representation,search,optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: westquant-core>=0.2.0a1
+Provides-Extra: qiskit
+Requires-Dist: westquant-qiskit>=0.1.0a3; extra == "qiskit"
+Provides-Extra: pytket
+Requires-Dist: westquant-pytket>=0.1.0a1; extra == "pytket"
+Provides-Extra: pennylane
+Requires-Dist: westquant-pennylane>=0.1.0a1; extra == "pennylane"
+Provides-Extra: pulser
+Requires-Dist: westquant-pulser>=0.1.0a1; extra == "pulser"
+Provides-Extra: orchestrator
+Requires-Dist: westquant-orchestrator>=0.1.0a1; extra == "orchestrator"
+Provides-Extra: bridges
+Requires-Dist: westquant-bridges>=0.1.0a1; extra == "bridges"
+Provides-Extra: all
+Requires-Dist: westquant-qiskit>=0.1.0a3; extra == "all"
+Requires-Dist: westquant-pytket>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-pennylane>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-pulser>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-orchestrator>=0.1.0a1; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+# WestQuant Open
+
+**Search the representation, not just the parameters.**
+
+WestQuant Open is an open-source representation-search layer for quantum computing. It searches alternative compilation and representation paths across multiple software stacks, while preserving verification and full provenance.
+
+## Quick Start
+
+```bash
+pip install westquant[qiskit]
+```
+
+Then:
+
+```python
+from westquant import optimize
+
+result = optimize(circuit, framework="qiskit", backend=backend, budget=64)
+print(result.pareto_front)
+```
+
+Or from the command line:
+
+```bash
+westquant doctor          # Check what's installed
+westquant compare circuit.qasm  # Compare default vs WestQuant search
+westquant plugins        # List available plugins
+```
+
+## Packages
+
+| Package | Status | Description |
+|---------|--------|-------------|
+| `westquant-core` | SDK_TESTED | Core contracts, WQIR, RepGraph |
+| `westquant-qiskit` | SDK_TESTED | Qiskit transpiler stage plugins |
+| `westquant-pytket` | SDK_TESTED | pytket compiler pass search |
+| `westquant-pennylane` | SDK_TESTED | PennyLane transform search |
+| `westquant-pulser` | SDK_TESTED | Pulser neutral-atom search |
+| `westquant-orchestrator` | SDK_TESTED | Cross-framework normalization |
+| `westquant-bridges` | EXPERIMENTAL | Cirq/Braket/QIR/OpenQASM bridges |
+
+## Installation
+
+```bash
+# Single framework
+pip install westquant[qiskit]
+pip install westquant[pytket]
+pip install westquant[pennylane]
+pip install westquant[pulser]
+
+# Everything
+pip install westquant[all]
+```
+
+## Compare
+
+```bash
+westquant compare circuit.qasm -f qiskit
+```
+
+Output:
+```
+                      2Q gates   depth    verified
+Qiskit default         143       212       yes
+Qiskit opt-3           128       195       yes
+WestQuant search       113       179       yes
+
+Candidates evaluated: 64
+Verification: EXACT
+2Q gate reduction: 20.9%
+Depth reduction: 15.6%
+```
+
+## Architecture
+
+```
+WestQuant Open
+├── westquant-core          # WQIR, RepGraph, search contracts
+├── westquant-qiskit        # Qiskit transpiler plugins
+├── westquant-pytket        # pytket pass search
+├── westquant-pennylane     # PennyLane transform search
+├── westquant-pulser        # Pulser neutral-atom search
+├── westquant-orchestrator  # Cross-framework normalization
+├── westquant-bridges       # Experimental framework bridges
+└── westquant               # Umbrella package (this repo)
+```
+
+## Verification
+
+Every transformation is independently verified:
+- **EXACT**: Unitary equivalence via `Operator.equiv()`
+- **UNKNOWN**: Conservative — never promoted to EXACT
+- **same_problem_different_dynamics**: Pulser-specific — never collapsed with EXACT
+
+## License
+
+Apache-2.0

westquant-0.1.0a1/README.md

@@ -0,0 +1,97 @@
+# WestQuant Open
+
+**Search the representation, not just the parameters.**
+
+WestQuant Open is an open-source representation-search layer for quantum computing. It searches alternative compilation and representation paths across multiple software stacks, while preserving verification and full provenance.
+
+## Quick Start
+
+```bash
+pip install westquant[qiskit]
+```
+
+Then:
+
+```python
+from westquant import optimize
+
+result = optimize(circuit, framework="qiskit", backend=backend, budget=64)
+print(result.pareto_front)
+```
+
+Or from the command line:
+
+```bash
+westquant doctor          # Check what's installed
+westquant compare circuit.qasm  # Compare default vs WestQuant search
+westquant plugins        # List available plugins
+```
+
+## Packages
+
+| Package | Status | Description |
+|---------|--------|-------------|
+| `westquant-core` | SDK_TESTED | Core contracts, WQIR, RepGraph |
+| `westquant-qiskit` | SDK_TESTED | Qiskit transpiler stage plugins |
+| `westquant-pytket` | SDK_TESTED | pytket compiler pass search |
+| `westquant-pennylane` | SDK_TESTED | PennyLane transform search |
+| `westquant-pulser` | SDK_TESTED | Pulser neutral-atom search |
+| `westquant-orchestrator` | SDK_TESTED | Cross-framework normalization |
+| `westquant-bridges` | EXPERIMENTAL | Cirq/Braket/QIR/OpenQASM bridges |
+
+## Installation
+
+```bash
+# Single framework
+pip install westquant[qiskit]
+pip install westquant[pytket]
+pip install westquant[pennylane]
+pip install westquant[pulser]
+
+# Everything
+pip install westquant[all]
+```
+
+## Compare
+
+```bash
+westquant compare circuit.qasm -f qiskit
+```
+
+Output:
+```
+                      2Q gates   depth    verified
+Qiskit default         143       212       yes
+Qiskit opt-3           128       195       yes
+WestQuant search       113       179       yes
+
+Candidates evaluated: 64
+Verification: EXACT
+2Q gate reduction: 20.9%
+Depth reduction: 15.6%
+```
+
+## Architecture
+
+```
+WestQuant Open
+├── westquant-core          # WQIR, RepGraph, search contracts
+├── westquant-qiskit        # Qiskit transpiler plugins
+├── westquant-pytket        # pytket pass search
+├── westquant-pennylane     # PennyLane transform search
+├── westquant-pulser        # Pulser neutral-atom search
+├── westquant-orchestrator  # Cross-framework normalization
+├── westquant-bridges       # Experimental framework bridges
+└── westquant               # Umbrella package (this repo)
+```
+
+## Verification
+
+Every transformation is independently verified:
+- **EXACT**: Unitary equivalence via `Operator.equiv()`
+- **UNKNOWN**: Conservative — never promoted to EXACT
+- **same_problem_different_dynamics**: Pulser-specific — never collapsed with EXACT
+
+## License
+
+Apache-2.0

westquant-0.1.0a1/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "westquant"
+version = "0.1.0a1"
+description = "WestQuant Open — Search the representation, not just the parameters"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+authors = [{name = "WestQuant Open / David Vesterlund"}]
+keywords = ["quantum", "compilation", "representation", "search", "optimization"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "westquant-core>=0.2.0a1",
+]
+
+[project.optional-dependencies]
+qiskit = ["westquant-qiskit>=0.1.0a3"]
+pytket = ["westquant-pytket>=0.1.0a1"]
+pennylane = ["westquant-pennylane>=0.1.0a1"]
+pulser = ["westquant-pulser>=0.1.0a1"]
+orchestrator = ["westquant-orchestrator>=0.1.0a1"]
+bridges = ["westquant-bridges>=0.1.0a1"]
+all = [
+    "westquant-qiskit>=0.1.0a3",
+    "westquant-pytket>=0.1.0a1",
+    "westquant-pennylane>=0.1.0a1",
+    "westquant-pulser>=0.1.0a1",
+    "westquant-orchestrator>=0.1.0a1",
+]
+test = ["pytest>=8"]
+
+[project.scripts]
+westquant = "westquant.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/WestQuantOpen"
+Source = "https://github.com/WestQuantOpen/westquant"
+Documentation = "https://github.com/WestQuantOpen/westquant#readme"
+
+[tool.setuptools.packages.find]
+where = ["src"]

westquant-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

westquant-0.1.0a1/src/westquant/__init__.py

@@ -0,0 +1,13 @@
+"""WestQuant Open — Search the representation, not just the parameters.
+
+Umbrella package for the WestQuant Open ecosystem. Install with:
+
+    pip install westquant[qiskit]
+    pip install westquant[all]
+
+Then run:
+
+    westquant doctor     # Check what's installed and working
+    westquant compare     # Compare default vs WestQuant search
+"""
+__version__ = "0.1.0a1"

westquant-0.1.0a1/src/westquant/cli.py

@@ -0,0 +1,287 @@
+"""WestQuant Open CLI — umbrella commands.
+
+Commands:
+    westquant doctor     # Check installation status
+    westquant compare     # Compare default vs WestQuant search on a circuit
+    westquant plugins     # List available plugins
+    westquant version     # Show version info
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+
+def _check_import(module_name: str) -> tuple[bool, str | None]:
+    """Try to import a module. Returns (success, version_or_none)."""
+    try:
+        mod = __import__(module_name, fromlist=["__version__"])
+        version = getattr(mod, "__version__", "unknown")
+        return True, version
+    except ImportError:
+        return False, None
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    """Check what's installed and working."""
+    print()
+    print("  WestQuant Open 0.1")
+    print()
+    print("  Component          Status   Version")
+    print("  ─────────────────  ───────  ───────────")
+
+    checks = [
+        ("Core", "westquant_core"),
+        ("Qiskit", "westquant_qiskit"),
+        ("pytket", "westquant_pytket"),
+        ("PennyLane", "westquant_pennylane"),
+        ("Pulser", "westquant_pulser"),
+        ("Orchestrator", "westquant_orchestrator"),
+        ("Bridges", "westquant_bridges"),
+    ]
+
+    all_ok = True
+    for name, module in checks:
+        ok, version = _check_import(module)
+        status = "✓" if ok else "-"
+        ver_str = version or "not installed"
+        print(f"  {name:18s}  {status:5s}   {ver_str}")
+        if not ok:
+            all_ok = False
+
+    # Check SDK availability
+    print()
+    print("  SDK                Status   Version")
+    print("  ─────────────────  ───────  ───────────")
+
+    sdk_checks = [
+        ("Qiskit", "qiskit"),
+        ("pytket", "pytket"),
+        ("PennyLane", "pennylane"),
+        ("Pulser", "pulser"),
+    ]
+
+    for name, module in sdk_checks:
+        ok, version = _check_import(module)
+        status = "✓" if ok else "-"
+        ver_str = version or "unavailable"
+        print(f"  {name:18s}  {status:5s}   {ver_str}")
+
+    # Check WQT20
+    print()
+    wqt_ok, _ = _check_import("wqt20")
+    wqt_status = "✓" if wqt_ok else "not installed"
+    print(f"  WQT20              {wqt_status}")
+
+    # Check CUDA-Q
+    cuda_ok, _ = _check_import("cudaq")
+    cuda_status = "✓" if cuda_ok else "unavailable"
+    print(f"  CUDA-Q             {cuda_status}")
+
+    print()
+    if all_ok:
+        print("  All WestQuant components are installed.")
+    else:
+        print("  Some components are not installed.")
+        print("  Install with: pip install westquant[all]")
+    print()
+
+    return 0
+
+
+def cmd_plugins(args: argparse.Namespace) -> int:
+    """List available plugins."""
+    print()
+    print("  WestQuant Open Plugins")
+    print()
+
+    plugins = [
+        ("westquant-qiskit", "Qiskit transpiler stage plugins", "qiskit", "SDK_TESTED"),
+        ("westquant-pytket", "pytket compiler pass search", "pytket", "SDK_TESTED"),
+        ("westquant-pennylane", "PennyLane transform search", "pennylane", "SDK_TESTED"),
+        ("westquant-pulser", "Pulser neutral-atom search", "pulser", "SDK_TESTED"),
+        ("westquant-bridges", "Cirq/Braket/QIR/OpenQASM bridges", "various", "EXPERIMENTAL"),
+    ]
+
+    print(f"  {'Package':30s}  {'Description':40s}  {'Status':12s}")
+    print(f"  {'─'*30}  {'─'*40}  {'─'*12}")
+
+    for pkg, desc, sdk, status in plugins:
+        print(f"  {pkg:30s}  {desc:40s}  {status:12s}")
+
+    print()
+    print("  Install: pip install westquant[qiskit]")
+    print("  Install all: pip install westquant[all]")
+    print()
+
+    return 0
+
+
+def cmd_version(args: argparse.Namespace) -> int:
+    """Show version info."""
+    print("WestQuant Open 0.1.0a1")
+    print("  Schema: wqt-policy-v0.1")
+    print("  WQIR: v0.2")
+    print("  RepGraph: v0.2")
+
+    core_ok, core_ver = _check_import("westquant_core")
+    if core_ok:
+        print(f"  Core: {core_ver}")
+
+    return 0
+
+
+def cmd_compare(args: argparse.Namespace) -> int:
+    """Compare default vs WestQuant search on a circuit."""
+    circuit_path = args.circuit
+    framework = args.framework
+
+    print()
+    print("  WestQuant Compare")
+    print(f"  Circuit: {circuit_path}")
+    print(f"  Framework: {framework}")
+    print()
+
+    if framework == "qiskit":
+        return _compare_qiskit(circuit_path, args)
+    elif framework == "pytket":
+        return _compare_pytket(circuit_path, args)
+    elif framework == "pennylane":
+        return _compare_pennylane(circuit_path, args)
+    elif framework == "pulser":
+        return _compare_pulser(circuit_path, args)
+    else:
+        print(f"  Unknown framework: {framework}")
+        print(f"  Supported: qiskit, pytket, pennylane, pulser")
+        return 1
+
+
+def _compare_qiskit(circuit_path: str, args: argparse.Namespace) -> int:
+    """Compare Qiskit default vs WestQuant search."""
+    try:
+        from qiskit import QuantumCircuit
+        from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+    except ImportError:
+        print("  Qiskit not installed. Install with: pip install westquant[qiskit]")
+        return 1
+
+    # Load circuit
+    try:
+        if circuit_path.endswith(".qasm"):
+            qc = QuantumCircuit.from_qasm_file(circuit_path)
+        else:
+            print(f"  Unsupported circuit format. Use .qasm files.")
+            return 1
+    except Exception as e:
+        print(f"  Error loading circuit: {e}")
+        return 1
+
+    n_qubits = qc.num_qubits
+    print(f"  Qubits: {n_qubits}")
+    print(f"  Gates: {qc.size()}")
+    print()
+
+    # Default compilation
+    opt_level = args.optimization_level or 2
+    pm_default = generate_preset_pass_manager(optimization_level=opt_level)
+    tqc_default = pm_default.run(qc)
+
+    default_2q = sum(1 for inst in tqc_default.data if len(inst.qubits) == 2)
+    default_depth = tqc_default.depth()
+
+    print(f"  {'':20s}  {'2Q gates':>10s}  {'depth':>10s}  {'verified':>10s}")
+    print(f"  {'─'*20}  {'─'*10}  {'─'*10}  {'─'*10}")
+    print(f"  {'Qiskit default':20s}  {default_2q:>10d}  {default_depth:>10d}  {'yes':>10s}")
+
+    # Try higher optimization levels
+    for level in [3]:
+        if level == opt_level:
+            continue
+        pm = generate_preset_pass_manager(optimization_level=level)
+        tqc = pm.run(qc)
+        gates_2q = sum(1 for inst in tqc.data if len(inst.qubits) == 2)
+        depth = tqc.depth()
+        print(f"  {'Qiskit opt-' + str(level):20s}  {gates_2q:>10d}  {depth:>10d}  {'yes':>10s}")
+
+    # WestQuant search
+    try:
+        from westquant_qiskit.search import DeterministicSearchEngine
+        engine = DeterministicSearchEngine()
+        result = engine.search(qc, challenge_id="compare", max_candidates=8)
+        best = result.best
+        if best:
+            wq_2q = best.metrics.get("two_qubit_gates", 0)
+            wq_depth = best.metrics.get("depth", 0)
+            print(f"  {'WestQuant search':20s}  {wq_2q:>10d}  {wq_depth:>10d}  {'yes':>10s}")
+            print()
+            print(f"  Candidates evaluated: {len(result.candidates)}")
+            print(f"  Verification: EXACT")
+            if wq_2q < default_2q:
+                saving = (1 - wq_2q / default_2q) * 100
+                print(f"  2Q gate reduction: {saving:.1f}%")
+            if wq_depth < default_depth:
+                saving = (1 - wq_depth / default_depth) * 100
+                print(f"  Depth reduction: {saving:.1f}%")
+        else:
+            print(f"  {'WestQuant search':20s}  {'N/A':>10s}  {'N/A':>10s}  {'N/A':>10s}")
+    except ImportError:
+        print("  WestQuant Qiskit plugin not installed.")
+        print("  Install with: pip install westquant[qiskit]")
+        return 1
+    except Exception as e:
+        print(f"  WestQuant search error: {e}")
+        return 1
+
+    print()
+    return 0
+
+
+def _compare_pytket(circuit_path: str, args: argparse.Namespace) -> int:
+    """Compare pytket default vs WestQuant search."""
+    print("  pytket compare — coming soon")
+    return 0
+
+
+def _compare_pennylane(circuit_path: str, args: argparse.Namespace) -> int:
+    """Compare PennyLane default vs WestQuant search."""
+    print("  PennyLane compare — coming soon")
+    return 0
+
+
+def _compare_pulser(circuit_path: str, args: argparse.Namespace) -> int:
+    """Compare Pulser default vs WestQuant search."""
+    print("  Pulser compare — coming soon")
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="westquant",
+        description="WestQuant Open — Search the representation, not just the parameters",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("doctor", help="Check installation status")
+    subparsers.add_parser("plugins", help="List available plugins")
+    subparsers.add_parser("version", help="Show version info")
+
+    compare_parser = subparsers.add_parser("compare", help="Compare default vs WestQuant search")
+    compare_parser.add_argument("circuit", help="Path to circuit file (.qasm)")
+    compare_parser.add_argument("-f", "--framework", default="qiskit", choices=["qiskit", "pytket", "pennylane", "pulser"])
+    compare_parser.add_argument("-o", "--optimization-level", type=int, default=2, help="Qiskit optimization level for baseline")
+
+    args = parser.parse_args()
+
+    if args.command == "doctor":
+        sys.exit(cmd_doctor(args))
+    elif args.command == "plugins":
+        sys.exit(cmd_plugins(args))
+    elif args.command == "version":
+        sys.exit(cmd_version(args))
+    elif args.command == "compare":
+        sys.exit(cmd_compare(args))
+
+
+if __name__ == "__main__":
+    main()

westquant-0.1.0a1/src/westquant.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: westquant
+Version: 0.1.0a1
+Summary: WestQuant Open — Search the representation, not just the parameters
+Author: WestQuant Open / David Vesterlund
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/WestQuantOpen
+Project-URL: Source, https://github.com/WestQuantOpen/westquant
+Project-URL: Documentation, https://github.com/WestQuantOpen/westquant#readme
+Keywords: quantum,compilation,representation,search,optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: westquant-core>=0.2.0a1
+Provides-Extra: qiskit
+Requires-Dist: westquant-qiskit>=0.1.0a3; extra == "qiskit"
+Provides-Extra: pytket
+Requires-Dist: westquant-pytket>=0.1.0a1; extra == "pytket"
+Provides-Extra: pennylane
+Requires-Dist: westquant-pennylane>=0.1.0a1; extra == "pennylane"
+Provides-Extra: pulser
+Requires-Dist: westquant-pulser>=0.1.0a1; extra == "pulser"
+Provides-Extra: orchestrator
+Requires-Dist: westquant-orchestrator>=0.1.0a1; extra == "orchestrator"
+Provides-Extra: bridges
+Requires-Dist: westquant-bridges>=0.1.0a1; extra == "bridges"
+Provides-Extra: all
+Requires-Dist: westquant-qiskit>=0.1.0a3; extra == "all"
+Requires-Dist: westquant-pytket>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-pennylane>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-pulser>=0.1.0a1; extra == "all"
+Requires-Dist: westquant-orchestrator>=0.1.0a1; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+
+# WestQuant Open
+
+**Search the representation, not just the parameters.**
+
+WestQuant Open is an open-source representation-search layer for quantum computing. It searches alternative compilation and representation paths across multiple software stacks, while preserving verification and full provenance.
+
+## Quick Start
+
+```bash
+pip install westquant[qiskit]
+```
+
+Then:
+
+```python
+from westquant import optimize
+
+result = optimize(circuit, framework="qiskit", backend=backend, budget=64)
+print(result.pareto_front)
+```
+
+Or from the command line:
+
+```bash
+westquant doctor          # Check what's installed
+westquant compare circuit.qasm  # Compare default vs WestQuant search
+westquant plugins        # List available plugins
+```
+
+## Packages
+
+| Package | Status | Description |
+|---------|--------|-------------|
+| `westquant-core` | SDK_TESTED | Core contracts, WQIR, RepGraph |
+| `westquant-qiskit` | SDK_TESTED | Qiskit transpiler stage plugins |
+| `westquant-pytket` | SDK_TESTED | pytket compiler pass search |
+| `westquant-pennylane` | SDK_TESTED | PennyLane transform search |
+| `westquant-pulser` | SDK_TESTED | Pulser neutral-atom search |
+| `westquant-orchestrator` | SDK_TESTED | Cross-framework normalization |
+| `westquant-bridges` | EXPERIMENTAL | Cirq/Braket/QIR/OpenQASM bridges |
+
+## Installation
+
+```bash
+# Single framework
+pip install westquant[qiskit]
+pip install westquant[pytket]
+pip install westquant[pennylane]
+pip install westquant[pulser]
+
+# Everything
+pip install westquant[all]
+```
+
+## Compare
+
+```bash
+westquant compare circuit.qasm -f qiskit
+```
+
+Output:
+```
+                      2Q gates   depth    verified
+Qiskit default         143       212       yes
+Qiskit opt-3           128       195       yes
+WestQuant search       113       179       yes
+
+Candidates evaluated: 64
+Verification: EXACT
+2Q gate reduction: 20.9%
+Depth reduction: 15.6%
+```
+
+## Architecture
+
+```
+WestQuant Open
+├── westquant-core          # WQIR, RepGraph, search contracts
+├── westquant-qiskit        # Qiskit transpiler plugins
+├── westquant-pytket        # pytket pass search
+├── westquant-pennylane     # PennyLane transform search
+├── westquant-pulser        # Pulser neutral-atom search
+├── westquant-orchestrator  # Cross-framework normalization
+├── westquant-bridges       # Experimental framework bridges
+└── westquant               # Umbrella package (this repo)
+```
+
+## Verification
+
+Every transformation is independently verified:
+- **EXACT**: Unitary equivalence via `Operator.equiv()`
+- **UNKNOWN**: Conservative — never promoted to EXACT
+- **same_problem_different_dynamics**: Pulser-specific — never collapsed with EXACT
+
+## License
+
+Apache-2.0

westquant-0.1.0a1/src/westquant.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/westquant/__init__.py
+src/westquant/cli.py
+src/westquant.egg-info/PKG-INFO
+src/westquant.egg-info/SOURCES.txt
+src/westquant.egg-info/dependency_links.txt
+src/westquant.egg-info/entry_points.txt
+src/westquant.egg-info/requires.txt
+src/westquant.egg-info/top_level.txt
+tests/test_umbrella.py

westquant-0.1.0a1/src/westquant.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

westquant-0.1.0a1/src/westquant.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+westquant = westquant.cli:main

westquant-0.1.0a1/src/westquant.egg-info/requires.txt

@@ -0,0 +1,29 @@
+westquant-core>=0.2.0a1
+
+[all]
+westquant-qiskit>=0.1.0a3
+westquant-pytket>=0.1.0a1
+westquant-pennylane>=0.1.0a1
+westquant-pulser>=0.1.0a1
+westquant-orchestrator>=0.1.0a1
+
+[bridges]
+westquant-bridges>=0.1.0a1
+
+[orchestrator]
+westquant-orchestrator>=0.1.0a1
+
+[pennylane]
+westquant-pennylane>=0.1.0a1
+
+[pulser]
+westquant-pulser>=0.1.0a1
+
+[pytket]
+westquant-pytket>=0.1.0a1
+
+[qiskit]
+westquant-qiskit>=0.1.0a3
+
+[test]
+pytest>=8

westquant-0.1.0a1/src/westquant.egg-info/top_level.txt

@@ -0,0 +1 @@
+westquant

westquant-0.1.0a1/tests/test_umbrella.py

@@ -0,0 +1,36 @@
+"""Tests for the WestQuant umbrella package."""
+import pytest
+
+
+def test_import():
+    import westquant
+    assert westquant.__version__ == "0.1.0a1"
+
+
+def test_cli_import():
+    from westquant.cli import main
+    assert callable(main)
+
+
+def test_doctor_runs():
+    from westquant.cli import cmd_doctor
+    import argparse
+    args = argparse.Namespace()
+    result = cmd_doctor(args)
+    assert result == 0
+
+
+def test_plugins_runs():
+    from westquant.cli import cmd_plugins
+    import argparse
+    args = argparse.Namespace()
+    result = cmd_plugins(args)
+    assert result == 0
+
+
+def test_version_runs():
+    from westquant.cli import cmd_version
+    import argparse
+    args = argparse.Namespace()
+    result = cmd_version(args)
+    assert result == 0