algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/reasoning/mcts.py

@@ -0,0 +1,220 @@
+"""Monte Carlo Tree Search (MCTS) for Reasoning.
+
+Implements UCT (Upper Confidence bounds applied to Trees) for reasoning:
+- Selection: Pick the most promising node using UCB1
+- Expansion: Generate child thoughts from the selected node
+- Simulation: Roll out to estimate value (lightweight or via LLM)
+- Backpropagation: Update statistics up the tree
+
+Effective for deep reasoning tasks where exploration-exploitation
+tradeoffs matter. Integrates with ToT for structured tree search.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..chat_protocol import get_attr
+
+
+@dataclass
+class MCTSNode:
+    """A node in the MCTS search tree."""
+    thought: str
+    state: str  # Accumulated reasoning state
+    parent: "MCTSNode | None" = field(default=None, repr=False)
+    children: list["MCTSNode"] = field(default_factory=list)
+    visits: int = 0
+    total_value: float = 0.0
+    depth: int = 0
+    fully_expanded: bool = False
+    terminal: bool = False
+
+    @property
+    def avg_value(self) -> float:
+        return self.total_value / max(1, self.visits)
+
+    @property
+    def ucb1(self) -> float:
+        """UCT score with exploration constant sqrt(2)."""
+        if self.visits == 0:
+            return float("inf")
+        exploitation = self.avg_value
+        exploration = math.sqrt(2.0 * math.log(max(1, self.parent.visits if self.parent else 1)) / self.visits)
+        return exploitation + exploration
+
+    def best_child(self) -> "MCTSNode | None":
+        """Select the child with the highest UCB1 score."""
+        if not self.children:
+            return None
+        return max(self.children, key=lambda c: c.ucb1)
+
+    def best_leaf(self) -> "MCTSNode":
+        """Find the most-visited leaf (most robust conclusion)."""
+        if not self.children:
+            return self
+        return max(self.children, key=lambda c: c.visits).best_leaf()
+
+    def reasoning_chain(self) -> str:
+        """Human-readable chain from root to this node."""
+        chain = []
+        node: MCTSNode | None = self
+        while node is not None:
+            chain.append(node)
+            node = node.parent
+        chain.reverse()
+        return "\n".join(
+            f"Step {i+1} (visits={n.visits}, val={n.avg_value:.2f}): {n.thought}"
+            for i, n in enumerate(chain)
+        )
+
+
+@dataclass
+class MCTSReasoner:
+    """MCTS-based reasoning engine."""
+    max_iterations: int = 50
+    max_depth: int = 6
+    branch_factor: int = 3
+    rollout_depth: int = 2
+    exploration_constant: float = math.sqrt(2.0)
+
+    root: MCTSNode | None = None
+    nodes_created: int = 0
+
+    def _select(self) -> MCTSNode:
+        """Selection: traverse tree following UCB1 to find a node to expand."""
+        node = self.root
+        while node and node.children and not node.terminal:
+            if not node.fully_expanded:
+                return node
+            selected = node.best_child()
+            if selected is None:
+                return node
+            node = selected
+        return node
+
+    def _expand(self, node: MCTSNode, client: Any, model: str) -> MCTSNode | None:
+        """Expansion: generate a new child thought from the selected node."""
+        prompt = (
+            f"Current reasoning state:\n{node.state[:1500]}\n\n"
+            f"Generate one next reasoning step (different from existing children if any).\n"
+            f"Existing steps: {[c.thought[:80] for c in node.children]}\n"
+            f"Respond with just the reasoning step and updated state as JSON:\n"
+            f'{{"thought": "...", "state": "..."}}'
+        )
+        try:
+            response = client.chat(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a reasoning step generator."},
+                    {"role": "user", "content": prompt},
+                ],
+                stream=False,
+                format="json",
+            )
+            text = get_attr(get_attr(response, "message", {}), "content", "")
+            data = json.loads(text)
+            thought = str(data.get("thought", ""))
+            state = str(data.get("state", node.state))
+        except (json.JSONDecodeError, ValueError, TypeError):
+            thought = f"(expansion at depth {node.depth + 1})"
+            state = node.state
+
+        child = MCTSNode(
+            thought=thought, state=state, parent=node,
+            depth=node.depth + 1,
+        )
+        node.children.append(child)
+        self.nodes_created += 1
+
+        if len(node.children) >= self.branch_factor:
+            node.fully_expanded = True
+
+        if node.depth + 1 >= self.max_depth:
+            child.terminal = True
+
+        return child
+
+    def _simulate(self, node: MCTSNode, client: Any, model: str) -> float:
+        """Simulation: quick rollout to estimate the node's value."""
+        prompt = (
+            f"Given this reasoning chain, rate the quality of the conclusion (0.0-1.0):\n"
+            f"{node.state[:1000]}\n\nRespond with just a number."
+        )
+        try:
+            response = client.chat(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a reasoning quality evaluator."},
+                    {"role": "user", "content": prompt},
+                ],
+                stream=False,
+            )
+            text = get_attr(get_attr(response, "message", {}), "content", "").strip()
+            import re
+            m = re.search(r"([0-9]*\.?[0-9]+)", text)
+            if m:
+                return max(0.0, min(1.0, float(m.group(1))))
+        except Exception:
+            pass
+        return 0.5
+
+    def _backpropagate(self, node: MCTSNode, value: float) -> None:
+        """Backpropagation: update statistics from leaf to root."""
+        current: MCTSNode | None = node
+        while current is not None:
+            current.visits += 1
+            current.total_value += value
+            current = current.parent
+
+
+def run_mcts(
+    *,
+    task: str,
+    client: Any,
+    model: str,
+    max_iterations: int = 50,
+    max_depth: int = 6,
+    branch_factor: int = 3,
+) -> MCTSReasoner:
+    """Run MCTS reasoning on a task.
+
+    Args:
+        task: The reasoning task.
+        client: Ollama client.
+        model: Model name for evaluation and generation.
+        max_iterations: Total MCTS iterations (select + expand + simulate + backprop).
+        max_depth: Maximum tree depth.
+        branch_factor: Max children per node.
+
+    Returns:
+        MCTSReasoner with root tree and best_leaf set.
+    """
+    reasoner = MCTSReasoner(
+        max_iterations=max_iterations,
+        max_depth=max_depth,
+        branch_factor=branch_factor,
+    )
+    reasoner.root = MCTSNode(thought="(root)", state=task, visits=1)
+
+    for _ in range(max_iterations):
+        # 1. Select
+        node = reasoner._select()
+        if node is None or node.terminal:
+            break
+
+        # 2. Expand
+        child = reasoner._expand(node, client, model)
+        if child is None:
+            break
+
+        # 3. Simulate
+        value = reasoner._simulate(child, client, model)
+
+        # 4. Backpropagate
+        reasoner._backpropagate(child, value)
+
+    return reasoner

algo_cli/reasoning/neuro_symbolic.py

@@ -0,0 +1,250 @@
+"""Neuro-Symbolic Verifier Loop.
+
+Implements a guess-and-check pattern:
+1. LLM proposes a solution (guess)
+2. Symbolic/structured verifier checks correctness (check)
+3. If verification fails, feed back the error and retry
+
+Verifiers include:
+- Python AST/expression evaluation for math/logic
+- JSON schema validation for structured outputs
+- Regex/grammar checks for format compliance
+- Unit-test-like assertions for code
+
+This dramatically reduces hallucination for formal domains.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..chat_protocol import get_attr
+
+
+@dataclass
+class VerificationResult:
+    """Result of verifying an LLM output."""
+    passed: bool
+    checks_total: int
+    checks_passed: int
+    failures: list[str] = field(default_factory=list)
+    suggestions: list[str] = field(default_factory=list)
+
+    @property
+    def score(self) -> float:
+        if self.checks_total == 0:
+            return 0.0
+        return self.checks_passed / self.checks_total
+
+    def feedback_message(self) -> str:
+        if self.passed:
+            return "All verification checks passed."
+        lines = [f"Verification failed: {self.checks_passed}/{self.checks_total} checks passed."]
+        for fail in self.failures:
+            lines.append(f"  - {fail}")
+        if self.suggestions:
+            lines.append("Suggestions:")
+            for s in self.suggestions:
+                lines.append(f"  + {s}")
+        return "\n".join(lines)
+
+
+@dataclass
+class NeuroSymbolicVerifier:
+    """LLM propose + symbolic verify loop."""
+    max_rounds: int = 3
+    verifiers: list[Callable[[str], VerificationResult]] = field(default_factory=list)
+
+    def verify(self, output: str) -> VerificationResult:
+        """Run all registered verifiers against the LLM output."""
+        if not self.verifiers:
+            return VerificationResult(passed=True, checks_total=0, checks_passed=0)
+        total = 0
+        passed = 0
+        failures: list[str] = []
+        suggestions: list[str] = []
+        for verifier in self.verifiers:
+            result = verifier(output)
+            total += result.checks_total
+            passed += result.checks_passed
+            failures.extend(result.failures)
+            suggestions.extend(result.suggestions)
+        return VerificationResult(
+            passed=passed == total and total > 0,
+            checks_total=total,
+            checks_passed=passed,
+            failures=failures,
+            suggestions=suggestions,
+        )
+
+    def add_verifier(self, verifier: Callable[[str], VerificationResult]) -> "NeuroSymbolicVerifier":
+        self.verifiers.append(verifier)
+        return self
+
+
+# --- Built-in verifiers ---
+
+def json_schema_verifier(schema: dict[str, Any]) -> Callable[[str], VerificationResult]:
+    """Create a verifier that checks if output is valid JSON matching a schema."""
+    def verify(output: str) -> VerificationResult:
+        failures: list[str] = []
+        try:
+            data = json.loads(output)
+        except json.JSONDecodeError as e:
+            return VerificationResult(
+                passed=False, checks_total=1, checks_passed=0,
+                failures=[f"Invalid JSON: {e}"],
+                suggestions=["Ensure output is valid JSON."],
+            )
+        # Check required keys
+        required = schema.get("required", [])
+        for key in required:
+            if key not in data:
+                failures.append(f"Missing required key: {key}")
+        # Check types
+        properties = schema.get("properties", {})
+        for key, expected_type in properties.items():
+            if key in data:
+                actual_type = type(data[key]).__name__
+                if expected_type != actual_type:
+                    failures.append(f"Key '{key}' has type {actual_type}, expected {expected_type}")
+        passed = len(failures) == 0
+        return VerificationResult(
+            passed=passed,
+            checks_total=len(required) + len(properties),
+            checks_passed=len(required) + len(properties) - len(failures),
+            failures=failures,
+            suggestions=["Fix the schema violations listed above."],
+        )
+    return verify
+
+
+def python_syntax_verifier(output: str) -> VerificationResult:
+    """Verify that Python code in the output is syntactically valid."""
+    # Extract code blocks
+    code_blocks = re.findall(r"```python\n(.*?)```", output, re.DOTALL)
+    if not code_blocks:
+        # Check if entire output looks like code
+        if any(kw in output for kw in ["def ", "class ", "import "]):
+            code_blocks = [output]
+        else:
+            return VerificationResult(passed=True, checks_total=0, checks_passed=0)
+
+    failures: list[str] = []
+    for i, code in enumerate(code_blocks):
+        try:
+            ast.parse(code)
+        except SyntaxError as e:
+            failures.append(f"Code block {i+1}: SyntaxError at line {e.lineno}: {e.msg}")
+
+    return VerificationResult(
+        passed=len(failures) == 0,
+        checks_total=len(code_blocks),
+        checks_passed=len(code_blocks) - len(failures),
+        failures=failures,
+        suggestions=["Fix syntax errors in the code blocks."],
+    )
+
+
+def regex_format_verifier(pattern: str, description: str = "") -> Callable[[str], VerificationResult]:
+    """Create a verifier that checks if output matches a regex pattern."""
+    desc = description or f"matches pattern: {pattern[:50]}"
+    def verify(output: str) -> VerificationResult:
+        if re.search(pattern, output):
+            return VerificationResult(passed=True, checks_total=1, checks_passed=1)
+        return VerificationResult(
+            passed=False, checks_total=1, checks_passed=0,
+            failures=[f"Output does not {desc}"],
+            suggestions=[f"Ensure the output {desc}"],
+        )
+    return verify
+
+
+def assertion_verifier(assertions: list[tuple[str, str]]) -> Callable[[str], VerificationResult]:
+    """Create a verifier from a list of (pattern, description) assertions.
+
+    Each assertion is a (regex_pattern, description) tuple.
+    The output must match ALL patterns.
+    """
+    def verify(output: str) -> VerificationResult:
+        failures: list[str] = []
+        for pattern, desc in assertions:
+            if not re.search(pattern, output):
+                failures.append(f"Assertion failed: {desc}")
+        return VerificationResult(
+            passed=len(failures) == 0,
+            checks_total=len(assertions),
+            checks_passed=len(assertions) - len(failures),
+            failures=failures,
+        )
+    return verify
+
+
+VERIFY_PROMPT_TEMPLATE = """You previously produced this output:
+
+{output}
+
+Verification found these issues:
+{feedback}
+
+Please revise your output to address all verification failures.
+Produce the corrected output only, without explaining the changes."""
+
+
+def run_neuro_symbolic(
+    *,
+    task: str,
+    client: Any,
+    model: str,
+    verifiers: list[Callable[[str], VerificationResult]],
+    max_rounds: int = 3,
+    system: str = "You are a precise reasoning agent. Produce output that passes all verification checks.",
+) -> tuple[str, list[VerificationResult]]:
+    """Run a neuro-symbolic guess-and-check loop.
+
+    Args:
+        task: The task to solve.
+        client: Ollama client.
+        model: Model name.
+        verifiers: List of verification functions.
+        max_rounds: Maximum guess-and-check rounds.
+        system: System prompt.
+
+    Returns:
+        (final_output, verification_history)
+    """
+    ns = NeuroSymbolicVerifier(max_rounds=max_rounds, verifiers=verifiers)
+    messages: list[dict[str, Any]] = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": task},
+    ]
+    history: list[VerificationResult] = []
+    output = ""
+
+    for round_num in range(max_rounds):
+        try:
+            response = client.chat(model=model, messages=messages, stream=False)
+            output = get_attr(get_attr(response, "message", {}), "content", "").strip()
+        except Exception as exc:
+            output = f"Error: {exc}"
+
+        # Verify
+        result = ns.verify(output)
+        history.append(result)
+
+        if result.passed:
+            break
+
+        # Feed back failures for retry
+        feedback = result.feedback_message()
+        messages.append({"role": "assistant", "content": output})
+        messages.append({
+            "role": "user",
+            "content": VERIFY_PROMPT_TEMPLATE.format(output=output[:2000], feedback=feedback),
+        })
+
+    return output, history