"""Thinking operators (Def 4.1 / Appendix B of MindFlow). Each operator is an atomic, reusable LLM-agent routine O=(P,{Q},{T}) that performs a distinct cognitive function. Operators consume the current structured idea y=(title, problem, method, evaluation) (Eq. 2) plus the topic and related works, and emit a new/refined structured idea. """ from __future__ import annotations import json from . import llm # Canonical structured-idea schema (Eq. 2): y = (y_t, y_p, y_m, y_e) IDEA_KEYS = ["title", "problem", "method", "evaluation"] _SYS = ( "You are an expert AI research scientist generating rigorous, novel and feasible " "research ideas. Always answer with a single JSON object with keys " '"title", "problem", "method", "evaluation". ' '"problem" states the motivation, research gap and a testable hypothesis; ' '"method" gives the core technical approach, key components, assumptions, datasets and metrics; ' '"evaluation" gives baselines, ablations and success criteria. Be concrete and specific.' ) def _fmt_idea(idea): if not idea: return "(none yet)" return json.dumps({k: idea.get(k, "") for k in IDEA_KEYS}, indent=1) def _fmt_context(topic, related): rw = "\n".join(f"- {r}" for r in (related or [])[:6]) or "(none provided)" return f"RESEARCH TOPIC:\n{topic}\n\nRELATED WORKS (inspiration):\n{rw}" def _run(prompt, topic, related, idea, model=None, temperature=0.7, seed=None, max_tokens=900): msgs = [ {"role": "system", "content": _SYS}, {"role": "user", "content": f"{_fmt_context(topic, related)}\n\nCURRENT IDEA:\n{_fmt_idea(idea)}\n\n{prompt}"}, ] obj = llm.chat_json(msgs, model=model, temperature=temperature, seed=seed, max_tokens=max_tokens) # normalise: keep the 4 keys, fall back to previous idea for missing fields out = {} for k in IDEA_KEYS: v = obj.get(k) out[k] = v if isinstance(v, str) and v.strip() else (idea.get(k, "") if idea else "") return out # ---- operator implementations ------------------------------------------------- def op_generate(topic, related, idea=None, **kw): p = ("GENERATE: Produce an initial, complete research idea for this topic, grounded in the " "related works. This is the default proposal.") return _run(p, topic, related, None, temperature=0.9, **kw) def op_generate_cot(topic, related, idea=None, **kw): p = ("GENERATE with chain-of-thought: First think step by step about the gaps, prior work and possible " "approaches (reason internally), THEN produce a single complete research idea as the JSON object.") return _run(p, topic, related, None, temperature=0.9, max_tokens=1400, **kw) def op_divergent(topic, related, idea, **kw): """Fallback single-output form (best alternative). The flow executor prefers op_divergent_expand to branch into a candidate pool.""" p = ("DIVERGENT THINKING: Expand the search space. Propose a markedly different alternative " "framing for the CURRENT IDEA and return it. Prioritise originality and breadth.") return _run(p, topic, related, idea, temperature=1.0, **kw) def op_divergent_expand(topic, related, idea, n=3, model=None, seed=None): """Divergent branching: return up to n diverse candidate ideas (one LLM call).""" schema = ('Respond ONLY with a JSON object {"alternatives": [ {"title","problem","method",' '"evaluation"}, ... ]} containing %d markedly different, diverse alternatives.' % n) msgs = [ {"role": "system", "content": _SYS}, {"role": "user", "content": f"{_fmt_context(topic, related)}\n\nCURRENT IDEA:\n{_fmt_idea(idea)}\n\n" f"DIVERGENT THINKING: Expand the search space by generating {n} markedly different alternative " f"directions/framings for the current idea (different problems or methods, not minor tweaks). {schema}"}] obj = llm.chat_json(msgs, model=model, temperature=1.0, seed=seed, max_tokens=1800) alts = obj.get("alternatives") if isinstance(obj, dict) else None out = [] for a in (alts or [])[:n]: if isinstance(a, dict): out.append({k: (a.get(k) if isinstance(a.get(k), str) else (idea.get(k, "") if idea else "")) for k in IDEA_KEYS}) if not out: out = [op_divergent(topic, related, idea, model=model, seed=seed)] return out def op_convergent(topic, related, idea, **kw): p = ("CONVERGENT THINKING: Synthesise, rank and select the strongest elements of the CURRENT IDEA " "into a single coherent, high-quality and well-scoped proposal. Remove redundancy; sharpen the " "contribution.") return _run(p, topic, related, idea, temperature=0.4, **kw) def op_convergent_select(topic, related, candidates, model=None, seed=None): """Convergent selection over a candidate pool (Prompt E): pick the single most novel/promising/feasible idea. Falls back to sharpening if only one candidate.""" candidates = [c for c in candidates if c] if len(candidates) <= 1: return op_convergent(topic, related, candidates[0] if candidates else None, model=model, seed=seed) letters = [chr(ord("A") + i) for i in range(len(candidates))] listing = "\n\n".join(f"Idea {L}:\n{_fmt_idea(c)}" for L, c in zip(letters, candidates)) msgs = [ {"role": "system", "content": _SYS}, {"role": "user", "content": f"{_fmt_context(topic, related)}\n\nSeveral candidate ideas have been proposed:\n\n{listing}\n\n" "CONVERGENT THINKING: Carefully evaluate these candidates and select the ONE that is most novel, " 'promising and feasible. Respond ONLY with JSON {"solution_letter":"", "title","problem",' '"method","evaluation"} where the four idea fields are the refined, sharpened version of the selected idea.'}] obj = llm.chat_json(msgs, model=model, temperature=0.3, seed=seed, max_tokens=1300) L = str(obj.get("solution_letter", "")).strip().upper()[:1] base = candidates[letters.index(L)] if L in letters else candidates[0] out = {} for k in IDEA_KEYS: v = obj.get(k) out[k] = v if isinstance(v, str) and v.strip() else base.get(k, "") return out def op_critical(topic, related, idea, **kw): p = ("CRITICAL THINKING: Stress-test the CURRENT IDEA. List its top weaknesses, hidden assumptions and " "verification risks, then return a REVISED idea with targeted fixes that address them. Improve " "significance and feasibility.") return _run(p, topic, related, idea, temperature=0.5, **kw) def op_analogical(topic, related, idea, **kw): p = ("ANALOGICAL THINKING: Transfer structure from a related but different problem/field to the CURRENT " "IDEA, proposing a new formulation or solution route by analogy. Name the source analogy explicitly " "in the method.") return _run(p, topic, related, idea, temperature=0.85, **kw) def op_counterfactual(topic, related, idea, **kw): p = ("COUNTERFACTUAL THINKING: Perturb a key assumption of the CURRENT IDEA (a 'what-if'), and return the " "resulting new idea that follows from relaxing/inverting that assumption. Maximise novelty.") return _run(p, topic, related, idea, temperature=1.0, **kw) def op_constraint(topic, related, idea, **kw): p = ("CONSTRAINT-DRIVEN THINKING: Impose explicit real-world constraints (available data, compute/cost " "budget, and a runnable experiment). Repair the CURRENT IDEA so its method and evaluation are " "concretely executable under these constraints. Improve feasibility.") return _run(p, topic, related, idea, temperature=0.4, **kw) # operator registry (Exit handled by the controller, no LLM call) OPERATORS = { "Generate": op_generate, "Divergent": op_divergent, "Convergent": op_convergent, "Critical": op_critical, "Analogical": op_analogical, "Counterfactual": op_counterfactual, "Constraint": op_constraint, } # Refinement operators the controller composes after the initial Generate (+ Exit). REFINE_OPS = ["Divergent", "Convergent", "Critical", "Analogical", "Counterfactual", "Constraint"] EXIT = "Exit" ALL_OPS = ["Generate"] + REFINE_OPS + [EXIT] # approximate per-operator execution cost C(G) in LLM-calls (used in Eq. 11 cost term) OP_COST = {name: 1.0 for name in OPERATORS} OP_COST[EXIT] = 0.0