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

algo_cli/reasoning/combinatorial.py

@@ -0,0 +1,356 @@
+"""QCR-LLM Quantum-Inspired Combinatorial Reasoning.
+
+Reformulates multi-sample Chain-of-Thought aggregation as a Higher-Order
+Unconstrained Binary Optimization (HUBO) problem, then solves it using
+classical simulated annealing (default) with optional QPU offload.
+
+Energy function:
+    H(x) = sum_{S subset [R], |S|<=K} w_S * prod_{i in S} x_i
+
+Weights w_S encode:
+- Popularity: how many samples agree on fragment i
+- Correlations: pairwise cosine similarity between fragment embeddings
+- Higher-order coherence: 3-body+ semantic consistency
+
+Local-first: uses simulated annealing by default.
+Quantum-ready: HUBO problem structure is QUBO-compatible for D-Wave,
+IBM Quantum (BF-DCQO), or IonQ via PennyLane/Qiskit adapters.
+"""
+
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..chat_protocol import get_attr
+
+
+@dataclass
+class HuboProblem:
+    """A Higher-Order Unconstrained Binary Optimization problem.
+
+    Represents the combinatorial optimization over which reasoning
+    fragments to include in the final aggregated answer.
+    """
+    n_variables: int  # Number of reasoning fragments (binary variables)
+    weights: dict[tuple[int, ...], float] = field(default_factory=dict)
+    # weights maps subset tuples to their coefficients:
+    #   (i,) -> unary weight (popularity)
+    #   (i, j) -> pairwise correlation
+    #   (i, j, k) -> higher-order coherence
+    labels: list[str] = field(default_factory=list)  # Fragment text for each variable
+
+    def energy(self, x: list[int]) -> float:
+        """Compute H(x) for a binary configuration."""
+        total = 0.0
+        for subset, weight in self.weights.items():
+            product = 1
+            for idx in subset:
+                if idx < len(x):
+                    product *= x[idx]
+                else:
+                    product = 0
+                    break
+            total += weight * product
+        return total
+
+    def to_qubo(self) -> dict[tuple[int, int], float]:
+        """Reduce HUBO to QUBO (pairwise) using substitution method.
+
+        Introduces auxiliary variables for higher-order terms.
+        For a term w_{ijk} * x_i * x_j * x_k, substitute x_i * x_j -> x_a
+        with penalty M * (x_a - 2*x_a*x_i - 2*x_a*x_j + 2*x_i*x_j).
+        """
+        qubo: dict[tuple[int, int], float] = {}
+        aux_var = self.n_variables  # Next available auxiliary variable index
+        M = max(abs(w) for w in self.weights.values()) * 2 if self.weights else 10.0
+
+        for subset, weight in self.weights.items():
+            if len(subset) == 1:
+                # Unary term
+                key = (subset[0], subset[0])
+                qubo[key] = qubo.get(key, 0.0) + weight
+            elif len(subset) == 2:
+                # Pairwise term
+                key = (subset[0], subset[1])
+                qubo[key] = qubo.get(key, 0.0) + weight
+            elif len(subset) >= 3:
+                # Higher-order: reduce iteratively
+                remaining = list(subset)
+                current_pair = (remaining[0], remaining[1])
+                # Create auxiliary variable for this pair
+                a = aux_var
+                aux_var += 1
+                # Penalty terms for substitution
+                qubo[(a, a)] = qubo.get((a, a), 0.0) - M * weight
+                qubo[(a, current_pair[0])] = qubo.get((a, current_pair[0]), 0.0) + M * weight
+                qubo[(a, current_pair[1])] = qubo.get((a, current_pair[1]), 0.0) + M * weight
+                qubo[(current_pair[0], current_pair[1])] = qubo.get(
+                    (current_pair[0], current_pair[1]), 0.0
+                ) - M * weight
+                # Remaining variables chain with auxiliary
+                for k in remaining[2:]:
+                    new_a = aux_var
+                    aux_var += 1
+                    qubo[(new_a, new_a)] = qubo.get((new_a, new_a), 0.0) - M * weight
+                    qubo[(new_a, a)] = qubo.get((new_a, a), 0.0) + M * weight
+                    qubo[(new_a, k)] = qubo.get((new_a, k), 0.0) + M * weight
+                    qubo[(a, k)] = qubo.get((a, k), 0.0) - M * weight
+                    a = new_a
+
+        return qubo
+
+
+def build_hubo_from_fragments(
+    fragments: list[str],
+    embeddings: list[list[float]] | None = None,
+    popularity: list[float] | None = None,
+    order: int = 3,
+    correlation_weight: float = 0.5,
+    coherence_weight: float = 0.2,
+) -> HuboProblem:
+    """Build a HUBO problem from reasoning fragments.
+
+    Args:
+        fragments: List of reasoning fragment texts.
+        embeddings: Optional pre-computed embeddings for correlation computation.
+        popularity: Optional pre-computed popularity scores (uniform if not given).
+        order: Maximum interaction order (1=unary, 2=pairwise, 3=three-body).
+        correlation_weight: Weight for pairwise correlation terms.
+        coherence_weight: Weight for higher-order coherence terms.
+
+    Returns:
+        A HuboProblem ready for optimization.
+    """
+    n = len(fragments)
+    problem = HuboProblem(n_variables=n, labels=fragments)
+
+    # Unary: popularity
+    pop = popularity or [1.0 / n] * n
+    for i in range(n):
+        problem.weights[(i,)] = pop[i]
+
+    # Pairwise: cosine similarity
+    if embeddings and len(embeddings) == n:
+        for i in range(n):
+            for j in range(i + 1, n):
+                sim = _cosine_sim(embeddings[i], embeddings[j])
+                if abs(sim) > 0.01:
+                    problem.weights[(i, j)] = correlation_weight * sim
+
+    # Higher-order coherence (3-body)
+    if order >= 3 and embeddings and len(embeddings) == n:
+        for i in range(n):
+            for j in range(i + 1, n):
+                for k in range(j + 1, n):
+                    # Three-body coherence: geometric mean of pairwise similarities
+                    sim_ij = _cosine_sim(embeddings[i], embeddings[j])
+                    sim_ik = _cosine_sim(embeddings[i], embeddings[k])
+                    sim_jk = _cosine_sim(embeddings[j], embeddings[k])
+                    coherence = math.pow(max(0, sim_ij * sim_ik * sim_jk), 1.0 / 3)
+                    if coherence > 0.01:
+                        problem.weights[(i, j, k)] = coherence_weight * coherence
+
+    return problem
+
+
+def _cosine_sim(a: list[float], b: list[float]) -> float:
+    """Compute cosine similarity between two vectors."""
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(x * x for x in b))
+    if na == 0.0 or nb == 0.0:
+        return 0.0
+    return dot / (na * nb)
+
+
+def simulated_annealing(
+    problem: HuboProblem,
+    *,
+    initial_temp: float = 2.0,
+    final_temp: float = 0.01,
+    cooling_rate: float = 0.95,
+    steps_per_temp: int = 50,
+    seed: int | None = None,
+) -> tuple[list[int], float]:
+    """Solve HUBO using classical simulated annealing.
+
+    Args:
+        problem: The HUBO problem.
+        initial_temp: Starting temperature.
+        final_temp: Stopping temperature.
+        cooling_rate: Temperature decay factor.
+        steps_per_temp: Monte Carlo steps per temperature.
+        seed: Random seed for reproducibility.
+
+    Returns:
+        (best_solution, best_energy) where solution is binary vector.
+    """
+    rng = random.Random(seed)
+    n = problem.n_variables
+
+    # Initialize randomly
+    current = [rng.randint(0, 1) for _ in range(n)]
+    current_energy = problem.energy(current)
+    best = list(current)
+    best_energy = current_energy
+
+    temp = initial_temp
+    while temp > final_temp:
+        for _ in range(steps_per_temp):
+            # Flip a random variable
+            flip_idx = rng.randint(0, n - 1)
+            candidate = list(current)
+            candidate[flip_idx] = 1 - candidate[flip_idx]
+            candidate_energy = problem.energy(candidate)
+
+            delta = candidate_energy - current_energy
+            # We MINIMIZE energy (HUBO: lower is better for negative correlation weights)
+            # But for QCR-LLM, we want to MAXIMIZE quality, so we negate
+            # Convention: positive weights = good, so we maximize energy
+            if delta > 0 or rng.random() < math.exp(delta / temp):
+                current = candidate
+                current_energy = candidate_energy
+                if current_energy > best_energy:
+                    best = list(current)
+                    best_energy = current_energy
+
+        temp *= cooling_rate
+
+    return best, best_energy
+
+
+@dataclass
+class QCRAggregator:
+    """QCR-LLM style combinatorial reasoning aggregator.
+
+    Generates multiple CoT fragments from the LLM, embeds them,
+    builds a HUBO problem, and solves it to select the best subset.
+    """
+    n_samples: int = 5
+    order: int = 3
+    correlation_weight: float = 0.5
+    coherence_weight: float = 0.2
+    sa_initial_temp: float = 2.0
+    sa_cooling_rate: float = 0.95
+    embed_fn: Callable[[list[str]], list[list[float]]] | None = None
+
+    def generate_fragments(
+        self, task: str, client: Any, model: str, n: int | None = None,
+    ) -> list[str]:
+        """Generate multiple CoT reasoning fragments."""
+        n = n or self.n_samples
+        fragments: list[str] = []
+        for _ in range(n):
+            try:
+                response = client.chat(
+                    model=model,
+                    messages=[
+                        {"role": "system", "content": "You are a reasoning agent. Think step by step."},
+                        {"role": "user", "content": task},
+                    ],
+                    stream=False,
+                    options={"temperature": 0.7},  # Higher temp for diversity
+                )
+                text = get_attr(get_attr(response, "message", {}), "content", "").strip()
+                if text:
+                    fragments.append(text)
+            except Exception:
+                continue
+        return fragments
+
+    def aggregate(self, fragments: list[str]) -> tuple[list[int], float, HuboProblem]:
+        """Build HUBO and solve to select the best fragment subset.
+
+        Returns (selected_indices, total_energy, problem).
+        """
+        embeddings = None
+        if self.embed_fn and fragments:
+            try:
+                embeddings = self.embed_fn(fragments)
+            except Exception:
+                pass
+
+        problem = build_hubo_from_fragments(
+            fragments,
+            embeddings=embeddings,
+            order=self.order,
+            correlation_weight=self.correlation_weight,
+            coherence_weight=self.coherence_weight,
+        )
+
+        solution, energy = simulated_annealing(
+            problem,
+            initial_temp=self.sa_initial_temp,
+            cooling_rate=self.sa_cooling_rate,
+        )
+        selected = [i for i, x in enumerate(solution) if x == 1]
+        return selected, energy, problem
+
+
+def run_qcr_aggregation(
+    *,
+    task: str,
+    client: Any,
+    model: str,
+    n_samples: int = 5,
+    embed_fn: Callable[[list[str]], list[list[float]]] | None = None,
+    order: int = 3,
+) -> tuple[str, list[str], dict[str, Any]]:
+    """Run a complete QCR-LLM aggregation pipeline.
+
+    Args:
+        task: The reasoning task.
+        client: Ollama client.
+        model: Model name for fragment generation.
+        n_samples: Number of CoT fragments to generate.
+        embed_fn: Optional embedding function for correlation computation.
+        order: Maximum HUBO interaction order.
+
+    Returns:
+        (aggregated_answer, selected_fragments, metadata)
+    """
+    aggregator = QCRAggregator(n_samples=n_samples, embed_fn=embed_fn, order=order)
+
+    # 1. Generate diverse reasoning fragments
+    fragments = aggregator.generate_fragments(task, client, model)
+    if not fragments:
+        return "(no fragments generated)", [], {"error": "generation_failed"}
+
+    # 2. Build and solve HUBO
+    selected_indices, energy, problem = aggregator.aggregate(fragments)
+    selected_fragments = [fragments[i] for i in selected_indices if i < len(fragments)]
+
+    # 3. Synthesize selected fragments into a final answer
+    if not selected_fragments:
+        selected_fragments = fragments[:1]  # Fallback to first fragment
+
+    synthesis_prompt = (
+        "Synthesize these reasoning fragments into a single coherent answer:\n\n"
+        + "\n\n---\n\n".join(f"Fragment {i+1}:\n{f[:1500]}" for i, f in enumerate(selected_fragments))
+    )
+    try:
+        response = client.chat(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a reasoning synthesizer. Combine diverse perspectives into a unified answer."},
+                {"role": "user", "content": synthesis_prompt},
+            ],
+            stream=False,
+        )
+        answer = get_attr(get_attr(response, "message", {}), "content", "").strip()
+    except Exception:
+        answer = selected_fragments[0] if selected_fragments else "(synthesis failed)"
+
+    metadata = {
+        "total_fragments": len(fragments),
+        "selected_count": len(selected_fragments),
+        "selected_indices": selected_indices,
+        "energy": energy,
+        "hubo_terms": len(problem.weights),
+    }
+    return answer, selected_fragments, metadata

algo_cli/reasoning/graph_of_thought.py

@@ -0,0 +1,297 @@
+"""Graph-of-Thoughts (GoT) Reasoning.
+
+Generalizes ToT to arbitrary directed acyclic graphs (DAGs) where:
+- Thoughts are vertices with typed edges
+- Supports merge (combine multiple thoughts), feedback (revise), and distill (compact)
+- Closer to recurrent/human cognition patterns
+- Better for tasks requiring iterative refinement or synthesis of partial results
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from ..chat_protocol import get_attr
+
+
+class EdgeType(Enum):
+    NEXT = "next"          # Sequential reasoning step
+    MERGE = "merge"        # Combine multiple thoughts
+    FEEDBACK = "feedback"  # Revise a thought based on downstream info
+    DISTILL = "distill"    # Compact intermediate reasoning
+
+
+@dataclass
+class ThoughtVertex:
+    """A vertex in the Graph-of-Thought."""
+    id: str
+    thought: str
+    value: float
+    kind: str = "reasoning"  # reasoning, hypothesis, evidence, synthesis
+    state: str = ""
+    timestamp: float = field(default_factory=time.time)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_context(self) -> str:
+        return f"[{self.id}] ({self.kind}, val={self.value:.2f}): {self.thought[:300]}"
+
+
+@dataclass
+class ThoughtEdge:
+    """A directed edge connecting two thought vertices."""
+    source_id: str
+    target_id: str
+    edge_type: EdgeType
+    label: str = ""
+    weight: float = 1.0
+
+
+@dataclass
+class GraphOfThought:
+    """Graph-of-Thought reasoner."""
+    vertices: dict[str, ThoughtVertex] = field(default_factory=dict)
+    edges: list[ThoughtEdge] = field(default_factory=list)
+    next_id: int = 0
+    best_vertex: ThoughtVertex | None = None
+    best_score: float = 0.0
+
+    def add_vertex(self, thought: str, value: float, kind: str = "reasoning", state: str = "") -> ThoughtVertex:
+        vid = f"v{self.next_id}"
+        self.next_id += 1
+        vertex = ThoughtVertex(id=vid, thought=thought, value=value, kind=kind, state=state)
+        self.vertices[vid] = vertex
+        if value > self.best_score:
+            self.best_score = value
+            self.best_vertex = vertex
+        return vertex
+
+    def add_edge(self, source_id: str, target_id: str, edge_type: EdgeType, label: str = "") -> ThoughtEdge:
+        edge = ThoughtEdge(source_id=source_id, target_id=target_id, edge_type=edge_type, label=label)
+        self.edges.append(edge)
+        return edge
+
+    def predecessors(self, vertex_id: str) -> list[ThoughtVertex]:
+        """Return vertices with edges pointing into this vertex."""
+        pred_ids = {e.source_id for e in self.edges if e.target_id == vertex_id}
+        return [self.vertices[pid] for pid in pred_ids if pid in self.vertices]
+
+    def successors(self, vertex_id: str) -> list[ThoughtVertex]:
+        """Return vertices this vertex points to."""
+        succ_ids = {e.target_id for e in self.edges if e.source_id == vertex_id}
+        return [self.vertices[sid] for sid in succ_ids if sid in self.vertices]
+
+    def frontier(self) -> list[ThoughtVertex]:
+        """Return leaf vertices (no successors) that could be expanded."""
+        has_children = {e.source_id for e in self.edges}
+        return [v for v in self.vertices.values() if v.id not in has_children]
+
+    def context_snapshot(self, max_chars: int = 4000) -> str:
+        """Serialize the graph state for LLM context."""
+        lines = ["## Current Reasoning Graph"]
+        total = 0
+        for v in self.vertices.values():
+            entry = v.to_context()
+            if total + len(entry) > max_chars:
+                lines.append(f"... ({len(self.vertices)} total vertices)")
+                break
+            lines.append(entry)
+            total += len(entry)
+        if self.edges:
+            lines.append(f"\nEdges: {len(self.edges)} connections")
+        return "\n".join(lines)
+
+    def _merge_thoughts(self, vertex_ids: list[str], client: Any, model: str) -> ThoughtVertex | None:
+        """Merge multiple thoughts into a synthesis vertex."""
+        vertices = [self.vertices[vid] for vid in vertex_ids if vid in self.vertices]
+        if not vertices:
+            return None
+        parts = [v.to_context() for v in vertices]
+        prompt = (
+            "Synthesize these reasoning steps into one unified thought:\n\n"
+            + "\n\n".join(parts)
+            + "\n\nProduce a single concise synthesis."
+        )
+        try:
+            response = client.chat(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a reasoning synthesizer."},
+                    {"role": "user", "content": prompt},
+                ],
+                stream=False,
+            )
+            text = get_attr(get_attr(response, "message", {}), "content", "").strip()
+        except Exception:
+            text = " + ".join(v.thought[:80] for v in vertices)
+
+        merged = self.add_vertex(thought=text, value=max(v.value for v in vertices), kind="synthesis")
+        for vid in vertex_ids:
+            if vid in self.vertices:
+                self.add_edge(vid, merged.id, EdgeType.MERGE, label="merge")
+        return merged
+
+    def _feedback_loop(self, vertex_id: str, client: Any, model: str) -> ThoughtVertex | None:
+        """Apply feedback: revise a thought using information from its successors."""
+        vertex = self.vertices.get(vertex_id)
+        if not vertex:
+            return None
+        successors = self.successors(vertex_id)
+        if not successors:
+            return None
+        succ_context = "\n".join(s.to_context() for s in successors)
+        prompt = (
+            f"Original thought [{vertex_id}]: {vertex.thought}\n\n"
+            f"Downstream findings:\n{succ_context}\n\n"
+            "Revise the original thought to incorporate these findings."
+        )
+        try:
+            response = client.chat(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a reasoning reviser."},
+                    {"role": "user", "content": prompt},
+                ],
+                stream=False,
+            )
+            text = get_attr(get_attr(response, "message", {}), "content", "").strip()
+        except Exception:
+            text = vertex.thought
+
+        revised = self.add_vertex(thought=text, value=vertex.value + 0.1, kind="revised")
+        self.add_edge(vertex_id, revised.id, EdgeType.FEEDBACK, label="revise")
+        # Connect the original successors to the revised version
+        for s in successors:
+            self.add_edge(revised.id, s.id, EdgeType.NEXT, label="post-revision")
+        return revised
+
+    def _distill(self, vertex_ids: list[str], client: Any, model: str) -> ThoughtVertex | None:
+        """Distill a set of vertices into a compact summary vertex."""
+        vertices = [self.vertices[vid] for vid in vertex_ids if vid in self.vertices]
+        if not vertices:
+            return None
+        prompt = (
+            "Distill these reasoning steps into a compact summary (max 200 words):\n\n"
+            + "\n\n".join(v.to_context() for v in vertices)
+        )
+        try:
+            response = client.chat(
+                model=model,
+                messages=[
+                    {"role": "system", "content": "You are a reasoning compactor."},
+                    {"role": "user", "content": prompt},
+                ],
+                stream=False,
+            )
+            text = get_attr(get_attr(response, "message", {}), "content", "").strip()
+        except Exception:
+            text = " | ".join(v.thought[:60] for v in vertices)
+
+        distilled = self.add_vertex(thought=text, value=max(v.value for v in vertices), kind="distilled")
+        for vid in vertex_ids:
+            if vid in self.vertices:
+                self.add_edge(vid, distilled.id, EdgeType.DISTILL, label="distill")
+        return distilled
+
+
+EXPANSION_PROMPT = """Given the reasoning graph state and the task, generate {n} next reasoning steps.
+
+Task: {task}
+
+{graph_context}
+
+Produce {n} distinct next thoughts as JSON array:
+[{{"thought": "...", "kind": "reasoning|hypthesis|evidence", "state": "updated state"}}]"""
+
+
+def run_got(
+    *,
+    task: str,
+    client: Any,
+    model: str,
+    max_rounds: int = 4,
+    branch_factor: int = 2,
+    enable_merge: bool = True,
+    enable_feedback: bool = True,
+    enable_distill: bool = True,
+    distill_threshold: int = 6,
+) -> GraphOfThought:
+    """Run a Graph-of-Thought reasoning episode.
+
+    Args:
+        task: The reasoning task.
+        client: Ollama client.
+        model: Model name.
+        max_rounds: Maximum expansion rounds.
+        branch_factor: Thoughts generated per frontier node.
+        enable_merge: Allow merge operations.
+        enable_feedback: Allow feedback loops.
+        enable_distill: Allow distillation when graph gets large.
+        distill_threshold: Distill when vertex count exceeds this.
+
+    Returns:
+        The GraphOfThought with best_vertex set.
+    """
+    got = GraphOfThought()
+
+    # Seed with initial thought
+    got.add_vertex(thought=f"Task: {task}", value=1.0, kind="hypothesis", state=task)
+
+    for round_num in range(max_rounds):
+        frontier = got.frontier()
+        if not frontier:
+            break
+
+        # Expand frontier
+        for vertex in frontier[:3]:  # Limit expansion breadth
+            prompt = EXPANSION_PROMPT.format(
+                n=branch_factor,
+                task=task,
+                graph_context=got.context_snapshot(),
+            )
+            try:
+                response = client.chat(
+                    model=model,
+                    messages=[
+                        {"role": "system", "content": "You are a reasoning graph expander."},
+                        {"role": "user", "content": prompt},
+                    ],
+                    stream=False,
+                    format="json",
+                )
+                text = get_attr(get_attr(response, "message", {}), "content", "")
+                parsed = json.loads(text)
+                if isinstance(parsed, list):
+                    for item in parsed[:branch_factor]:
+                        if isinstance(item, dict):
+                            new_v = got.add_vertex(
+                                thought=str(item.get("thought", "")),
+                                value=0.5,
+                                kind=str(item.get("kind", "reasoning")),
+                                state=str(item.get("state", vertex.state)),
+                            )
+                            got.add_edge(vertex.id, new_v.id, EdgeType.NEXT)
+            except (json.JSONDecodeError, ValueError, TypeError):
+                # Fallback: add a simple continuation
+                new_v = got.add_vertex(thought=f"(continuation from {vertex.id})", value=0.4, kind="reasoning")
+                got.add_edge(vertex.id, new_v.id, EdgeType.NEXT)
+
+        # Merge phase: combine related frontier nodes
+        if enable_merge and len(frontier) >= 2:
+            got._merge_thoughts([v.id for v in frontier[:3]], client, model)
+
+        # Feedback phase: revise high-value nodes with successors
+        if enable_feedback and round_num >= 1:
+            high_value = [v for v in got.vertices.values() if v.value >= 0.6 and v.kind in ("hypothesis", "reasoning")]
+            for v in high_value[:2]:
+                got._feedback_loop(v.id, client, model)
+
+        # Distill phase: compact when graph is large
+        if enable_distill and len(got.vertices) > distill_threshold:
+            leaves = got.frontier()[:distill_threshold]
+            got._distill([v.id for v in leaves], client, model)
+
+    return got