westquant 0.1.0__py3-none-any.whl

westquant/__init__.py

@@ -0,0 +1,16 @@
+"""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.0a2"
+
+from .wqdf import WQDFSample, WQDF_VERSION, write_wqdf_jsonl, read_wqdf_jsonl, wqdf_schema
+from .generate import generate_training_data

westquant/cli.py

@@ -0,0 +1,365 @@
+"""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
+    westquant generate    # Generate ML training data from a circuit
+"""
+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.0a2")
+    print("  Schema: wqt-policy-v0.1")
+    print("  WQIR: v0.2")
+    print("  RepGraph: v0.2")
+    print("  WQDF: wqdf-v0.1")
+
+    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 cmd_generate(args: argparse.Namespace) -> int:
+    """Generate ML training data from a circuit."""
+    from .generate import generate_training_data
+
+    circuit_path = args.circuit_file
+    framework = args.framework
+    backend = args.backend
+    samples = args.samples
+    output = args.output
+    fmt = args.format
+
+    print()
+    print("  WestQuant ML Data Generation")
+    print(f"  Circuit: {circuit_path}")
+    print(f"  Framework: {framework}")
+    print(f"  Backend: {backend}")
+    print(f"  Max samples: {samples}")
+    print(f"  Output: {output} ({fmt})")
+    print()
+
+    # Load circuit
+    try:
+        if framework == "qiskit":
+            from qiskit import QuantumCircuit
+            if circuit_path.endswith(".qasm"):
+                qc = QuantumCircuit.from_qasm_file(circuit_path)
+            else:
+                print(f"  Unsupported circuit format. Use .qasm files.")
+                return 1
+        else:
+            print(f"  Framework {framework} circuit loading not yet supported in CLI.")
+            return 1
+    except ImportError:
+        print(f"  {framework} not installed. Install with: pip install westquant[{framework}]")
+        return 1
+    except Exception as e:
+        print(f"  Error loading circuit: {e}")
+        return 1
+
+    print(f"  Qubits: {qc.num_qubits}")
+    print()
+
+    # Generate
+    dataset = generate_training_data(
+        qc,
+        framework=framework,
+        backend=backend,
+        samples=samples,
+        output_format=fmt,
+        output_path=output,
+    )
+
+    print(f"  Generated {len(dataset)} samples")
+    if output:
+        print(f"  Written to: {output}")
+
+    # Show a few samples
+    for s in dataset[:3]:
+        print(f"    {s.sample_id}: depth={s.depth} 2q={s.two_qubit_gates} rep={s.representation}")
+    if len(dataset) > 3:
+        print(f"    ... ({len(dataset) - 3} more)")
+
+    print()
+    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")
+
+    generate_parser = subparsers.add_parser("generate", help="Generate ML training data from a circuit")
+    generate_parser.add_argument("circuit_file", help="Path to circuit file (.qasm)")
+    generate_parser.add_argument("-f", "--framework", default="qiskit", choices=["qiskit", "pytket", "pennylane", "pulser"])
+    generate_parser.add_argument("-b", "--backend", default="aer", help="Target backend")
+    generate_parser.add_argument("-n", "--samples", type=int, default=100, help="Maximum number of samples")
+    generate_parser.add_argument("-o", "--output", default="dataset.jsonl", help="Output path")
+    generate_parser.add_argument("--format", default="jsonl", choices=["jsonl", "csv", "parquet"], help="Output format")
+
+    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))
+    elif args.command == "generate":
+        sys.exit(cmd_generate(args))
+
+
+if __name__ == "__main__":
+    main()

westquant/generate.py

@@ -0,0 +1,316 @@
+"""WestQuant ML Data Generation.
+
+Generate structured datasets from quantum algorithms by varying
+representations, transpilation, parameters, noise models, and metrics.
+
+Open-source tier: basic grid search over representations.
+Commercial tier (not included): intelligent search, adaptive sampling,
+active learning, WQT-guided generation, hardware-aware generation.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import time
+from typing import Any
+from dataclasses import asdict
+
+from .wqdf import WQDFSample, WQDF_VERSION, write_wqdf_jsonl
+
+
+def generate_training_data(
+    circuit: Any,
+    *,
+    framework: str = "qiskit",
+    backend: str = "aer",
+    search_space: str = "representations",
+    samples: int = 100,
+    output_format: str = "jsonl",
+    output_path: str | None = None,
+    noise_models: list[str] | None = None,
+    basis_gates_options: list[list[str]] | None = None,
+    optimization_levels: list[int] | None = None,
+    layout_methods: list[str] | None = None,
+    routing_methods: list[str] | None = None,
+    seed: int = 0,
+) -> list[WQDFSample]:
+    """Generate ML training data from a quantum circuit.
+    
+    Varies over representations, transpilation configs, and optionally
+    noise models to produce a structured dataset.
+    
+    Args:
+        circuit: Input quantum circuit (Qiskit QuantumCircuit or compatible)
+        framework: Quantum framework ("qiskit", "pytket", "pennylane", "pulser")
+        backend: Target backend name
+        search_space: What to search over ("representations", "parameters", "all")
+        samples: Maximum number of samples to generate
+        output_format: Output format ("jsonl", "parquet", "csv", "dict")
+        output_path: If set, write to this path
+        noise_models: List of noise model identifiers to vary over
+        basis_gates_options: List of basis gate sets to try
+        optimization_levels: List of optimization levels to try
+        layout_methods: List of layout methods to try
+        routing_methods: List of routing methods to try
+        seed: Random seed for reproducibility
+    
+    Returns:
+        List of WQDFSample objects
+    
+    Example:
+        >>> from qiskit import QuantumCircuit
+        >>> qc = QuantumCircuit(4)
+        >>> # ... build circuit ...
+        >>> dataset = generate_training_data(
+        ...     qc,
+        ...     framework="qiskit",
+        ...     backend="aer",
+        ...     samples=1000,
+        ...     output_format="jsonl",
+        ...     output_path="training_data.jsonl",
+        ... )
+    """
+    # Default search dimensions
+    opt_levels = optimization_levels or [0, 1, 2, 3]
+    layouts = layout_methods or ["trivial", "dense", "sabre"]
+    routings = routing_methods or ["basic", "lookahead", "sabre"]
+    basis_opts = basis_gates_options or [None]  # None = use backend default
+    noises = noise_models or [""]
+    
+    # Build config grid
+    configs = list(itertools.product(opt_levels, layouts, routings, basis_opts, noises))
+    
+    # Limit to requested samples
+    if len(configs) > samples:
+        # Deterministic subsampling
+        step = len(configs) / samples
+        indices = [int(i * step) for i in range(samples)]
+        configs = [configs[i] for i in indices]
+    
+    results: list[WQDFSample] = []
+    
+    for idx, (opt_level, layout, routing, basis, noise) in enumerate(configs):
+        sample_id = f"wqdf-{framework}-{idx:06d}"
+        
+        # Try to compile and measure
+        try:
+            metrics = _compile_and_measure(
+                circuit,
+                framework=framework,
+                opt_level=opt_level,
+                layout=layout,
+                routing=routing,
+                basis_gates=basis,
+                backend=backend,
+                noise_model=noise,
+                seed=seed,
+            )
+        except Exception as exc:
+            metrics = {"error": str(exc), "compile_success": False}
+        
+        sample = WQDFSample(
+            problem=_detect_problem(circuit),
+            algorithm=_detect_algorithm(circuit),
+            circuit=_serialize_circuit(circuit),
+            representation=f"{framework}:{routing}:opt{opt_level}",
+            compilation_config={
+                "optimization_level": opt_level,
+                "layout_method": layout,
+                "routing_method": routing,
+                "basis_gates": basis,
+            },
+            backend=backend,
+            num_qubits=getattr(circuit, "num_qubits", 0),
+            depth=metrics.get("depth", 0),
+            two_qubit_gates=metrics.get("two_qubit_gates", 0),
+            size=metrics.get("size", 0),
+            swap_gates=metrics.get("swap_gates", 0),
+            noise_model=noise,
+            energy=metrics.get("energy"),
+            fidelity=metrics.get("fidelity"),
+            runtime=metrics.get("runtime"),
+            estimated_fidelity=metrics.get("estimated_fidelity"),
+            total_duration=metrics.get("total_duration"),
+            sample_id=sample_id,
+            framework=framework,
+        )
+        results.append(sample)
+    
+    # Write output if path provided
+    if output_path and output_format == "jsonl":
+        write_wqdf_jsonl(results, output_path)
+    elif output_path and output_format == "csv":
+        _write_csv(results, output_path)
+    elif output_path and output_format == "parquet":
+        _write_parquet(results, output_path)
+    
+    return results
+
+
+def _compile_and_measure(
+    circuit: Any,
+    *,
+    framework: str,
+    opt_level: int,
+    layout: str,
+    routing: str,
+    basis_gates: list[str] | None,
+    backend: str,
+    noise_model: str,
+    seed: int,
+) -> dict[str, Any]:
+    """Compile circuit with given config and measure metrics."""
+    if framework == "qiskit":
+        return _compile_qiskit(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed)
+    elif framework == "pytket":
+        return _compile_pytket(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed)
+    elif framework == "pennylane":
+        return _compile_pennylane(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed)
+    elif framework == "pulser":
+        return _compile_pulser(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed)
+    else:
+        return {"error": f"unknown framework: {framework}"}
+
+
+def _compile_qiskit(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed):
+    """Compile with Qiskit and return metrics."""
+    try:
+        from qiskit.transpiler import generate_preset_pass_manager
+        from westquant_qiskit.adapter import circuit_metrics
+        
+        kwargs = {
+            "optimization_level": opt_level,
+            "layout_method": layout,
+            "routing_method": routing,
+            "seed_transpiler": seed,
+        }
+        if basis_gates:
+            kwargs["basis_gates"] = basis_gates
+        
+        pm = generate_preset_pass_manager(**kwargs)
+        compiled = pm.run(circuit)
+        metrics = circuit_metrics(compiled)
+        metrics["compile_success"] = True
+        return metrics
+    except Exception as exc:
+        return {"compile_success": False, "error": str(exc)}
+
+
+def _compile_pytket(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed):
+    """Compile with pytket and return metrics."""
+    try:
+        from westquant_pytket.adapter import circuit_metrics
+        from westquant_pytket.search import PytketCompiler
+        from westquant_core import Action
+        
+        compiler = PytketCompiler()
+        prefix = [
+            Action("optimization", ["none", "redundancies", "peephole", "synthesise"][min(opt_level, 3)]),
+            Action("routing", routing if routing in ("none", "routing", "aas") else "none"),
+        ]
+        compiled = compiler.compile(circuit, prefix)
+        metrics = circuit_metrics(compiled)
+        metrics["compile_success"] = True
+        return metrics
+    except Exception as exc:
+        return {"compile_success": False, "error": str(exc)}
+
+
+def _compile_pennylane(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed):
+    """Compile with PennyLane and return metrics."""
+    try:
+        import pennylane as qml
+        # PennyLane transforms
+        tape = qml.tape.QuantumScript(circuit)
+        # Basic metrics
+        ops = list(tape.operations)
+        two_qubit = sum(1 for op in ops if len(op.wires) == 2)
+        return {
+            "n_qubits": len(tape.wires),
+            "depth": len(ops),
+            "size": len(ops),
+            "two_qubit_gates": two_qubit,
+            "swap_gates": 0,
+            "compile_success": True,
+        }
+    except Exception as exc:
+        return {"compile_success": False, "error": str(exc)}
+
+
+def _compile_pulser(circuit, opt_level, layout, routing, basis_gates, backend, noise_model, seed):
+    """Compile with Pulser and return metrics."""
+    try:
+        # Pulser sequence metrics
+        return {
+            "n_qubits": getattr(circuit, "n_atoms", 0),
+            "depth": 0,
+            "size": 0,
+            "two_qubit_gates": 0,
+            "swap_gates": 0,
+            "compile_success": True,
+        }
+    except Exception as exc:
+        return {"compile_success": False, "error": str(exc)}
+
+
+def _detect_problem(circuit: Any) -> str:
+    """Heuristically detect the problem class from a circuit."""
+    name = getattr(circuit, "name", "").lower()
+    if "qaoa" in name or "maxcut" in name:
+        return "combinatorial_optimization"
+    if "vqe" in name or "twolocal" in name:
+        return "variational_eigensolver"
+    if "grover" in name:
+        return "unstructured_search"
+    if "qft" in name:
+        return "fourier_transform"
+    if "qpe" in name:
+        return "phase_estimation"
+    return "unknown"
+
+
+def _detect_algorithm(circuit: Any) -> str:
+    """Heuristically detect the algorithm."""
+    name = getattr(circuit, "name", "").lower()
+    if name:
+        return name
+    n = getattr(circuit, "num_qubits", 0)
+    return f"circuit_{n}q"
+
+
+def _serialize_circuit(circuit: Any) -> str:
+    """Serialize circuit to QASM if possible."""
+    try:
+        return circuit.qasm()
+    except Exception:
+        try:
+            from qiskit.qasm3 import dumps
+            return dumps(circuit)
+        except Exception:
+            return ""
+
+
+def _write_csv(samples: list[WQDFSample], path: str) -> None:
+    """Write samples as CSV."""
+    import csv
+    if not samples:
+        return
+    fields = list(samples[0].to_dict().keys())
+    with open(path, "w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fields)
+        writer.writeheader()
+        for s in samples:
+            writer.writerow(s.to_dict())
+
+
+def _write_parquet(samples: list[WQDFSample], path: str) -> None:
+    """Write samples as Parquet."""
+    try:
+        import pandas as pd
+        df = pd.DataFrame([s.to_dict() for s in samples])
+        df.to_parquet(path)
+    except ImportError:
+        # Fallback to JSONL
+        jsonl_path = path.replace(".parquet", ".jsonl")
+        write_wqdf_jsonl(samples, jsonl_path)

westquant/wqdf.py

@@ -0,0 +1,134 @@
+"""WestQuant Dataset Format (WQDF) v0.1.
+
+A standard format for quantum ML training data. Each sample represents
+one (problem, representation, circuit, backend, result) tuple.
+
+Schema version: wqdf-v0.1
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from typing import Any
+import json
+
+
+WQDF_VERSION = "wqdf-v0.1"
+
+
+@dataclass
+class WQDFSample:
+    """One sample in a WestQuant Dataset Format dataset."""
+    
+    # Problem representation
+    problem: str = ""                    # e.g. "maxcut", "qaoa", "vqe"
+    problem_representation: dict[str, Any] = field(default_factory=dict)
+    
+    # Algorithm representation
+    algorithm: str = ""                 # e.g. "qaoa_p1", "vqe_twolocal"
+    algorithm_representation: dict[str, Any] = field(default_factory=dict)
+    
+    # Circuit representation
+    circuit: str = ""                   # QASM or serialized circuit
+    circuit_representation: dict[str, Any] = field(default_factory=dict)
+    
+    # Compilation representation
+    representation: str = ""             # e.g. "qiskit:sabre:opt3"
+    compilation_config: dict[str, Any] = field(default_factory=dict)
+    
+    # Hardware representation
+    backend: str = ""                   # e.g. "aer", "ibm_kyoto"
+    hardware_representation: dict[str, Any] = field(default_factory=dict)
+    
+    # Circuit metrics
+    num_qubits: int = 0
+    depth: int = 0
+    two_qubit_gates: int = 0
+    size: int = 0
+    swap_gates: int = 0
+    
+    # Noise model
+    noise_model: str = ""               # e.g. "depolarizing_0.01"
+    
+    # Result metrics
+    energy: float | None = None
+    fidelity: float | None = None
+    runtime: float | None = None
+    
+    # Cost metrics
+    estimated_fidelity: float | None = None
+    total_duration: float | None = None
+    
+    # Optimization trajectory
+    optimization_trajectory: list[dict[str, Any]] = field(default_factory=list)
+    
+    # Metadata
+    schema_version: str = WQDF_VERSION
+    sample_id: str = ""
+    framework: str = ""                  # "qiskit", "pytket", "pennylane", "pulser"
+    
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        d["schema_version"] = WQDF_VERSION
+        return d
+    
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), default=str)
+    
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "WQDFSample":
+        d = {k: v for k, v in d.items() if k in cls.__dataclass_fields__}
+        return cls(**d)
+
+
+def write_wqdf_jsonl(samples: list[WQDFSample], path: str) -> int:
+    """Write samples as WQDF JSONL. Returns number written."""
+    with open(path, "w") as f:
+        for s in samples:
+            f.write(s.to_json() + "\n")
+    return len(samples)
+
+
+def read_wqdf_jsonl(path: str) -> list[WQDFSample]:
+    """Read WQDF JSONL file."""
+    samples = []
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                samples.append(WQDFSample.from_dict(json.loads(line)))
+    return samples
+
+
+def wqdf_schema() -> dict[str, Any]:
+    """Return the WQDF v0.1 schema as a dict."""
+    return {
+        "schema_version": WQDF_VERSION,
+        "description": "WestQuant Dataset Format for quantum ML training data",
+        "fields": {
+            "problem": {"type": "str", "description": "Problem class (e.g. maxcut, qaoa, vqe)"},
+            "problem_representation": {"type": "dict", "description": "Problem-specific representation data"},
+            "algorithm": {"type": "str", "description": "Algorithm name"},
+            "algorithm_representation": {"type": "dict", "description": "Algorithm-specific data"},
+            "circuit": {"type": "str", "description": "Serialized circuit (QASM)"},
+            "circuit_representation": {"type": "dict", "description": "Circuit metrics and structure"},
+            "representation": {"type": "str", "description": "Compilation representation ID"},
+            "compilation_config": {"type": "dict", "description": "Compiler configuration"},
+            "backend": {"type": "str", "description": "Target backend"},
+            "hardware_representation": {"type": "dict", "description": "Hardware-specific data"},
+            "num_qubits": {"type": "int", "description": "Number of qubits"},
+            "depth": {"type": "int", "description": "Circuit depth"},
+            "two_qubit_gates": {"type": "int", "description": "Two-qubit gate count"},
+            "size": {"type": "int", "description": "Total gate count"},
+            "swap_gates": {"type": "int", "description": "SWAP gate count"},
+            "noise_model": {"type": "str", "description": "Noise model identifier"},
+            "energy": {"type": "float|None", "description": "Measured/computed energy"},
+            "fidelity": {"type": "float|None", "description": "State fidelity"},
+            "runtime": {"type": "float|None", "description": "Execution time in seconds"},
+            "estimated_fidelity": {"type": "float|None", "description": "Estimated circuit fidelity"},
+            "total_duration": {"type": "float|None", "description": "Total circuit duration"},
+            "optimization_trajectory": {"type": "list[dict]", "description": "Optimization steps"},
+            "sample_id": {"type": "str", "description": "Unique sample identifier"},
+            "framework": {"type": "str", "description": "Quantum framework used"},
+        }
+    }

westquant-0.1.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: westquant
+Version: 0.1.0
+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
+License-File: LICENSE
+License-File: NOTICE
+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"
+Dynamic: license-file
+
+# 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.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+westquant/__init__.py,sha256=EK6J8Bv7xYRZNZ2kUED6Cm8JgJgd6GB6hTmplYapX_Q,509
+westquant/cli.py,sha256=kVrn6NmlPQx7_x-KmuU9nop9-iLC2iaA9iq1RkBT8zw,12624
+westquant/generate.py,sha256=bAULYJUoPlSCBtHD6PQc-788NZxZo7bxv9PldvKo8Ns,11143
+westquant/wqdf.py,sha256=_cfcxsIjgkJY7NLntwjX1nmVCKyOcEwzyV8zV6Emqo0,5415
+westquant-0.1.0.dist-info/licenses/LICENSE,sha256=kdVF-ogehLOaSjHi56c_kGLGB23qQyLOzZ8yzIX0HEA,11351
+westquant-0.1.0.dist-info/licenses/NOTICE,sha256=hi4u-4w4WvlERoOi6swliYVFkRvnOj1UG4_ANO_7HFQ,384
+westquant-0.1.0.dist-info/METADATA,sha256=i_Wp15blqX-KFij6Xwrg4xNjwwN-7YBw9Izy83WSbio,4510
+westquant-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+westquant-0.1.0.dist-info/entry_points.txt,sha256=mg78TLt6KV1RFo4dj6ReYKN4PhGnS18bWjb4t-qOCzM,49
+westquant-0.1.0.dist-info/top_level.txt,sha256=dfe4Sg23qGY3qF89S6u_tZyDHlEqQI7tUXEsGRC56iw,10
+westquant-0.1.0.dist-info/RECORD,,

westquant-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

westquant-0.1.0.dist-info/entry_points.txt

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

westquant-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as a subdirectory of the NOTICE text file, provided that
+          such additional attribution notices cannot be construed as
+          modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 WestQuant Open Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

westquant-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,11 @@
+WestQuant Open
+Copyright 2026 WestQuant Open Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+This product includes software developed by the WestQuant Open project
+(https://github.com/WestQuantOpen).

westquant-0.1.0.dist-info/top_level.txt

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