qsl-quantum 0.2.0__py3-none-any.whl

qsl/__init__.py

@@ -0,0 +1,244 @@
+"""
+QSL - Quantum Search Language
+=============================
+
+Quantum computing framework supporting:
+    - Declarative quantum search (Grover)
+    - Quantum algorithms (QFT, Shor, QAOA, VQE)
+    - Quantum machine learning (QNN, QSVM, QGAN)
+    - Hardware backends (IBM, AWS Braket, Simulator)
+    - Circuit compiler optimization (gate fusion, transpiler, error mitigation)
+    - AI-powered quantum scientist (LLM translator, autonomous agent)
+    - Self-evolving quantum AI (genetic circuit search, RL compiler)
+    - Distributed quantum computing & quantum blockchain
+    - Application pipelines (drug discovery, crypto analysis, portfolio)
+
+Modes:
+    1. Classical simulator (default) - numpy-based, zero external deps
+    2. IBM quantum computer - requires qiskit
+    3. AWS Braket - requires boto3
+
+Quick start:
+    >>> from qsl import QSLProgram, QSLCompiler
+    >>> program = QSLProgram(name="test", n_qubits=3, premises=["x0 & x1"])
+    >>> compiler = QSLCompiler()
+    >>> result = compiler.compile_and_run(program)
+"""
+
+__version__ = "0.2.0"
+__author__ = "Song Ziming"
+__email__ = "15011462616@163.com"
+
+# ----------------------------------------------------------------
+# Core API (always available, zero deps)
+# ----------------------------------------------------------------
+from .compiler.program import QSLProgram
+from .compiler.compiler import QSLCompiler, compile_and_run, analyze
+from .compiler.dsl import parse_qsl
+from .core.parser import parse_bool
+from .core.state import QuantumState
+from .core.grover import GroverSearch, GroverResult, solve_sat
+from .backends.registry import list_backends, get_backend
+from .backends.simulator import SimulatorBackend
+
+# ----------------------------------------------------------------
+# Quantum Gates (requires numpy)
+# ----------------------------------------------------------------
+try:
+    from .quantum_gates import (
+        I, X, Y, Z, H, S, T,
+        rx, ry, rz, u3,
+        swap, cswap, mcx,
+        kron, controlled_gate,
+    )
+    _has_gates = True
+except ImportError:
+    _has_gates = False
+
+# ----------------------------------------------------------------
+# Quantum Algorithms (requires numpy, scipy optional)
+# ----------------------------------------------------------------
+try:
+    from .algorithms import (
+        QuantumFourierTransform,
+        ShorSolver,
+        QAOA,
+        VQE,
+    )
+    _has_algorithms = True
+except ImportError:
+    _has_algorithms = False
+
+# ----------------------------------------------------------------
+# Quantum Machine Learning (requires torch, scipy, sklearn)
+# ----------------------------------------------------------------
+try:
+    from .qml import QuantumLayer, QNN, quantum_kernel, QuantumSVM, QGAN
+    _has_qml = True
+except ImportError:
+    _has_qml = False
+
+# ----------------------------------------------------------------
+# Advanced Backends (requires qiskit, boto3)
+# ----------------------------------------------------------------
+try:
+    from .backends.ibm import IBMBackend
+    _has_ibm = True
+except ImportError:
+    _has_ibm = False
+
+try:
+    from .backends.aws_braket import AWSBraketBackend
+    _has_aws = True
+except ImportError:
+    _has_aws = False
+
+try:
+    from .backends.auto_selector import AutoBackend
+    _has_auto_backend = True
+except ImportError:
+    _has_auto_backend = False
+
+# ----------------------------------------------------------------
+# Compiler Optimizations (requires numpy)
+# ----------------------------------------------------------------
+try:
+    from .compiler.optimizer import gate_fusion, commutation_optimization, depth_reduction
+    from .compiler.transpiler import layout_mapping, swap_insertion, get_coupling_graph
+    _has_compiler_opt = True
+except ImportError:
+    _has_compiler_opt = False
+
+try:
+    from .compiler.error_mitigation import (
+        zne,
+        readout_error_correction,
+        build_confusion_matrix,
+        richardson_extrapolate,
+    )
+    _has_error_mitigation = True
+except ImportError:
+    _has_error_mitigation = False
+
+# ----------------------------------------------------------------
+# AI Scientist (requires openai, langchain)
+# ----------------------------------------------------------------
+try:
+    from .ai import (
+        ProblemTranslator,
+        QuantumAgent,
+        HypothesisTester,
+        DiscoveryPipeline,
+        ResultExplainer,
+    )
+    _has_ai = True
+except ImportError:
+    _has_ai = False
+
+# ----------------------------------------------------------------
+# Application Pipelines (requires core + algorithms)
+# ----------------------------------------------------------------
+try:
+    from .pipelines import (
+        DrugDiscoveryPipeline,
+        CryptoAnalysisPipeline,
+        PortfolioOptimizer,
+    )
+    _has_pipelines = True
+except ImportError:
+    _has_pipelines = False
+
+# ----------------------------------------------------------------
+# Meta / Self-Evolving System
+# ----------------------------------------------------------------
+try:
+    from .meta import AlgorithmSearcher, QuantumCompilerAI, QuantumTheoremProver
+    _has_meta = True
+except ImportError:
+    _has_meta = False
+
+# ----------------------------------------------------------------
+# Quantum Network
+# ----------------------------------------------------------------
+try:
+    from .network import (
+        DistributedNode,
+        QuantumCluster,
+        QuantumBlockchain,
+        QuantumBlock,
+    )
+    _has_network = True
+except ImportError:
+    _has_network = False
+
+# ----------------------------------------------------------------
+# Export list
+# ----------------------------------------------------------------
+__all__ = [
+    # Core
+    "QSLProgram",
+    "QSLCompiler",
+    "compile_and_run",
+    "analyze",
+    "parse_qsl",
+    "parse_bool",
+    "QuantumState",
+    "GroverSearch",
+    "GroverResult",
+    "solve_sat",
+    "SimulatorBackend",
+    "list_backends",
+    "get_backend",
+    # Gates
+    "I", "X", "Y", "Z", "H", "S", "T",
+    "rx", "ry", "rz", "u3",
+    "swap", "cswap", "mcx",
+    "kron", "controlled_gate",
+    # Algorithms
+    "QuantumFourierTransform",
+    "ShorSolver",
+    "QAOA",
+    "VQE",
+    # QML
+    "QuantumLayer",
+    "QNN",
+    "quantum_kernel",
+    "QuantumSVM",
+    "QGAN",
+    # Backends
+    "IBMBackend",
+    "AWSBraketBackend",
+    "AutoBackend",
+    # Compiler
+    "gate_fusion",
+    "commutation_optimization",
+    "depth_reduction",
+    "layout_mapping",
+    "swap_insertion",
+    "get_coupling_graph",
+    "zne",
+    "readout_error_correction",
+    "build_confusion_matrix",
+    "richardson_extrapolate",
+    # AI
+    "ProblemTranslator",
+    "QuantumAgent",
+    "HypothesisTester",
+    "DiscoveryPipeline",
+    "ResultExplainer",
+    # Pipelines
+    "DrugDiscoveryPipeline",
+    "CryptoAnalysisPipeline",
+    "PortfolioOptimizer",
+    # Meta
+    "AlgorithmSearcher",
+    "QuantumCompilerAI",
+    "QuantumTheoremProver",
+    # Network
+    "DistributedNode",
+    "QuantumCluster",
+    "QuantumBlockchain",
+    "QuantumBlock",
+    # Version
+    "__version__",
+]

qsl/__main__.py

@@ -0,0 +1,134 @@
+"""
+QSL 命令行入口。
+
+使用:
+    python -m qsl              # 交互式选择示例
+    python -m qsl --demo 1     # 运行指定示例
+"""
+
+import sys
+
+
+def main():
+    """命令行主入口。"""
+    from qsl import QSLProgram, QSLCompiler, parse_qsl
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--demo":
+        run_demo()
+    elif len(sys.argv) > 1 and sys.argv[1] == "--help":
+        print_help()
+    else:
+        run_interactive()
+
+
+def print_help():
+    print("""
+QSL - Quantum Search Language
+=============================
+
+用法:
+    python -m qsl             交互式模式
+    python -m qsl --demo 1    运行指定示例
+    python -m qsl --help      显示此帮助
+""")
+    print("""
+Python API:
+    >>> from qsl import QSLProgram, QSLCompiler
+    >>> program = QSLProgram(
+    ...     name="我的搜索问题",
+    ...     n_qubits=4,
+    ...     premises=["x0 & x1", "~x2 | x3"],
+    ...     shots=10
+    ... )
+    >>> compiler = QSLCompiler(backend="simulator")
+    >>> result = compiler.compile_and_run(program)
+""")
+
+
+def run_demo():
+    print("\n" + "=" * 60)
+    print("  QSL - Quantum Search Language v1.0.0")
+    print("  Grover 量子搜索演示")
+    print("=" * 60)
+
+    from qsl import QSLProgram, QSLCompiler
+
+    # 内嵌示例
+    demos = {
+        "1": ("SAT 求解 (n=3)", QSLProgram(
+            name="3-SAT 求解",
+            n_qubits=3,
+            premises=["x0 | ~x1", "x1 | x2", "~x0 | ~x2"],
+            shots=5,
+        )),
+        "2": ("图着色 (3顶点2色)", QSLProgram(
+            name="图着色",
+            n_qubits=3,
+            premises=["x0 ^ x1", "x1 ^ x2"],
+            shots=5,
+        )),
+        "3": ("恰好一个1 (n=3)", QSLProgram(
+            name="恰好一个1",
+            n_qubits=3,
+            premises=["x0 | x1 | x2", "~x0 | ~x1", "~x0 | ~x2", "~x1 | ~x2"],
+            shots=5,
+        )),
+        "4": ("大空间搜索 (n=6)", QSLProgram(
+            name="大空间搜索",
+            n_qubits=6,
+            premises=["~(x0 ^ x1 ^ x2)", "x3 | x4", "x5"],
+            shots=3,
+        )),
+    }
+
+    print("\n可用示例:")
+    for key, (desc, _) in demos.items():
+        print(f"  {key}. {desc}")
+    print(f"  0. 运行所有示例")
+
+    try:
+        choice = input("\n请选择 [0-4]: ").strip()
+        if not choice:
+            choice = "0"
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return
+
+    compiler = QSLCompiler(verbose=True)
+
+    if choice == "0":
+        for key, (desc, program) in demos.items():
+            print(f"\n{'─'*60}")
+            print(f"  示例 {key}: {desc}")
+            print(f"{'─'*60}")
+            try:
+                result = compiler.compile_and_run(program)
+                print(f"  结果: {result.summary()}")
+            except Exception as e:
+                print(f"  错误: {e}")
+    elif choice in demos:
+        desc, program = demos[choice]
+        print(f"\n{'─'*60}")
+        print(f"  示例 {choice}: {desc}")
+        print(f"{'─'*60}")
+        try:
+            result = compiler.compile_and_run(program)
+            print(f"  结果: {result.summary()}")
+        except Exception as e:
+            print(f"  错误: {e}")
+    else:
+        print(f"无效选择: {choice}")
+
+
+def run_interactive():
+    print("\n" + "=" * 60)
+    print("  QSL - Quantum Search Language v1.0.0")
+    print("  Quantum Search Language")
+    print("=" * 60)
+    print("\n用法: python -m qsl --demo    运行演示")
+    print("      python -m qsl --help    查看帮助")
+    print()
+
+
+if __name__ == "__main__":
+    main()

qsl/ai/__init__.py

@@ -0,0 +1,34 @@
+"""QSL AI Quantum Scientist - LLM-powered quantum computing automation."""
+
+try:
+    from .translator import ProblemTranslator
+except ImportError:
+    ProblemTranslator = None
+
+try:
+    from .agent import QuantumAgent
+except ImportError:
+    QuantumAgent = None
+
+try:
+    from .hypotheses import HypothesisTester
+except ImportError:
+    HypothesisTester = None
+
+try:
+    from .discovery import DiscoveryPipeline
+except ImportError:
+    DiscoveryPipeline = None
+
+try:
+    from .explainer import ResultExplainer
+except ImportError:
+    ResultExplainer = None
+
+__all__ = [
+    "ProblemTranslator",
+    "QuantumAgent", 
+    "HypothesisTester",
+    "DiscoveryPipeline",
+    "ResultExplainer",
+]

qsl/ai/agent.py

@@ -0,0 +1,275 @@
+"""
+Autonomous Quantum Agent - Self-directed quantum problem solving.
+"""
+
+import time
+from typing import Optional, Any
+from dataclasses import dataclass, field
+
+try:
+    from langchain.agents import AgentExecutor, create_react_agent
+    from langchain_openai import ChatOpenAI
+    from langchain.tools import Tool
+    HAS_LANGCHAIN = True
+except ImportError:
+    HAS_LANGCHAIN = False
+
+
+@dataclass
+class AgentResult:
+    """Result from a QuantumAgent run."""
+    task: str
+    success: bool
+    algorithm_used: str
+    backend_used: str
+    iterations: int
+    result_summary: str
+    data: dict = field(default_factory=dict)
+    error: Optional[str] = None
+
+
+class QuantumAgent:
+    """
+    Autonomous quantum computing agent.
+    
+    Decision chain:
+    LLM parse -> Select algorithm -> Select backend -> Compile -> Execute -> 
+    LLM explain results -> Decide iteration (max 3 rounds)
+    
+    Args:
+        task_description: Natural language task description
+        max_iterations: Maximum decision rounds (default 3)
+        verbose: Print progress messages
+    """
+    
+    def __init__(self,
+                 task_description: str,
+                 max_iterations: int = 3,
+                 verbose: bool = True):
+        self.task = task_description
+        self.max_iterations = max_iterations
+        self.verbose = verbose
+        self._llm = None
+        self._tools = []
+    
+    def _init_llm(self):
+        """Initialize LLM if available."""
+        if self._llm is not None:
+            return self._llm
+        
+        try:
+            import os
+            api_key = os.environ.get("OPENAI_API_KEY")
+            if not api_key:
+                if HAS_LANGCHAIN:
+                    self._llm = ChatOpenAI(model="gpt-4", api_key=api_key)
+                return self._llm
+            if HAS_LANGCHAIN:
+                self._llm = ChatOpenAI(model="gpt-4", api_key=api_key)
+        except Exception:
+            pass
+        
+        return self._llm
+    
+    def run(self) -> AgentResult:
+        """
+        Execute the agent's decision loop.
+        
+        Returns:
+            AgentResult with task outcome
+        """
+        if self.verbose:
+            print(f"\n{'='*60}")
+            print(f"  Quantum Agent: {self.task}")
+            print(f"{'='*60}")
+        
+        llm = self._init_llm()
+        
+        # Step 1: Parse task
+        algorithm, params = self._select_algorithm(llm)
+        if self.verbose:
+            print(f"  Selected algorithm: {algorithm}")
+        
+        # Step 2: Select backend
+        backend = self._select_backend(params)
+        if self.verbose:
+            print(f"  Selected backend: {backend}")
+        
+        # Step 3-5: Execute with retry loop
+        for iteration in range(1, self.max_iterations + 1):
+            try:
+                result = self._execute_quantum_task(algorithm, params, backend)
+                
+                if result.get("success", False):
+                    if self.verbose:
+                        print(f"  Iteration {iteration}: Success!")
+                    
+                    # LLM explain results
+                    explanation = self._explain_result(llm, result)
+                    
+                    return AgentResult(
+                        task=self.task,
+                        success=True,
+                        algorithm_used=algorithm,
+                        backend_used=backend,
+                        iterations=iteration,
+                        result_summary=explanation or "Task completed",
+                        data=result,
+                    )
+                else:
+                    if self.verbose:
+                        print(f"  Iteration {iteration}: Failed, retrying...")
+                    
+                    # Update parameters based on failure
+                    params = self._adjust_params(algorithm, params, result)
+            
+            except Exception as e:
+                if self.verbose:
+                    print(f"  Iteration {iteration}: Error - {e}")
+                if iteration >= self.max_iterations:
+                    return AgentResult(
+                        task=self.task,
+                        success=False,
+                        algorithm_used=algorithm,
+                        backend_used=backend,
+                        iterations=iteration,
+                        result_summary="Failed after max iterations",
+                        error=str(e),
+                    )
+        
+        return AgentResult(
+            task=self.task,
+            success=False,
+            algorithm_used=algorithm,
+            backend_used=backend,
+            iterations=self.max_iterations,
+            result_summary="Max iterations reached without success",
+        )
+    
+    def _select_algorithm(self, llm) -> tuple[str, dict]:
+        """Determine which quantum algorithm to use."""
+        task_lower = self.task.lower()
+        
+        if llm:
+            prompt = f"""Select the best quantum algorithm for this task.
+Options: grover, shor, qaoa, vqe
+
+Task: {self.task}
+
+Respond with just the algorithm name."""
+            try:
+                response = llm.invoke(prompt)
+                alg = response.content.strip().lower()
+                if alg in ("grover", "shor", "qaoa", "vqe"):
+                    return alg, {"n_qubits": 4}
+            except Exception:
+                pass
+        
+        # Fallback: keyword matching
+        if any(w in task_lower for w in ("factor", "rsa", "decrypt", "shor")):
+            return "shor", {"N": 15}
+        elif any(w in task_lower for w in ("optimize", "maxcut", "portfolio", "qaoa")):
+            return "qaoa", {"n_qubits": 4}
+        elif any(w in task_lower for w in ("energy", "ground", "chemistry", "vqe")):
+            return "vqe", {"n_qubits": 4}
+        else:
+            return "grover", {"n_qubits": 4, "premises": ["x0 & x1"]}
+    
+    def _select_backend(self, params: dict) -> str:
+        """Select optimal backend."""
+        n_qubits = params.get("n_qubits", 4)
+        if n_qubits <= 20:
+            return "simulator"
+        elif n_qubits <= 127:
+            return "ibm_kyoto"
+        else:
+            return "aws_sv1"
+    
+    def _execute_quantum_task(self, algorithm: str, params: dict, backend: str) -> dict:
+        """Execute the quantum computation."""
+        try:
+            if algorithm == "grover":
+                from ..compiler.program import QSLProgram
+                from ..compiler.compiler import QSLCompiler
+                
+                prog = QSLProgram(
+                    name=self.task,
+                    n_qubits=params.get("n_qubits", 4),
+                    premises=params.get("premises", ["x0 & x1"]),
+                    shots=100,
+                    backend=backend,
+                )
+                compiler = QSLCompiler(backend=backend)
+                result = compiler.compile_and_run(prog)
+                
+                solutions = result.get_solutions()
+                return {
+                    "success": len(solutions) > 0,
+                    "solutions": solutions,
+                    "iterations": result.iterations,
+                    "success_rate": result.empirical_success_rate,
+                }
+            
+            elif algorithm == "shor":
+                from ..algorithms.shor import ShorSolver
+                N = params.get("N", 15)
+                solver = ShorSolver(N)
+                factors = solver.factor()
+                return {
+                    "success": len(factors) > 0 and factors != [N],
+                    "factors": factors,
+                    "N": N,
+                }
+            
+            elif algorithm == "qaoa":
+                from ..algorithms.qaoa import QAOA
+                import numpy as np
+                n = params.get("n_qubits", 4)
+                cost = np.ones((n, n)) * 0.5
+                qaoa = QAOA(n, cost, p=1)
+                opt_params, energy = qaoa.optimize(maxiter=50)
+                best, best_cost = qaoa.get_optimal_bitstring()
+                return {
+                    "success": True,
+                    "energy": energy,
+                    "bitstring": best,
+                    "cost": best_cost,
+                }
+            
+            elif algorithm == "vqe":
+                from ..algorithms.vqe import VQE
+                h2 = VQE.h2_hamiltonian()
+                vqe = VQE(4, h2, ansatz_type="he", n_layers=1)
+                energy, state = vqe.optimize(maxiter=50)
+                return {
+                    "success": True,
+                    "energy": energy,
+                }
+            
+            else:
+                return {"success": False, "error": f"Unknown algorithm: {algorithm}"}
+        
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def _explain_result(self, llm, result: dict) -> Optional[str]:
+        """Use LLM to explain quantum results in natural language."""
+        if llm is None:
+            return str(result)
+        
+        prompt = f"""Explain the following quantum computation result in simple terms:
+Result: {result}
+
+Keep it concise (2-3 sentences)."""
+        
+        try:
+            response = llm.invoke(prompt)
+            return response.content.strip()
+        except Exception:
+            return str(result)
+    
+    def _adjust_params(self, algorithm: str, params: dict, result: dict) -> dict:
+        """Adjust parameters based on failure feedback."""
+        if "n_qubits" in params:
+            params["n_qubits"] = min(params["n_qubits"] + 1, 20)
+        return params