neurocore-skill-math 0.1.0__py3-none-any.whl

neurocore_skill_math/__init__.py

@@ -0,0 +1,72 @@
+"""neurocore-skill-math — a math-proof toolchain for NeuroCore.
+
+One package exposing many small composable skills (CAS, SMT, ATP, formal proof
+assistants). Each skill detects whether its backend tool is installed and degrades
+gracefully when it is not (status ``tool_unavailable``).
+"""
+from neurocore_skill_math.atp import (
+    EproverProveTptpSkill,
+    Mace4CountermodelSkill,
+    Prover9ProveSkill,
+    VampireProveTptpSkill,
+)
+from neurocore_skill_math.cas import (
+    GapGroupTheorySkill,
+    PariGpNumberTheorySkill,
+    SagemathComputeSkill,
+)
+from neurocore_skill_math.formal import (
+    CoqCheckSkill,
+    IsabelleCheckTheorySkill,
+    Lean4CheckSkill,
+    Lean4FormalizeStatementSkill,
+    Lean4RepairSkill,
+)
+from neurocore_skill_math.numeric import MpmathHighPrecisionCheckSkill
+from neurocore_skill_math.planning import LlmProofPlannerSkill, TheoremRetrieverSkill
+from neurocore_skill_math.prep import (
+    MathDomainClassifierSkill,
+    MathProblemParserSkill,
+    MathStatementNormalizerSkill,
+)
+from neurocore_skill_math.report import ProofReportBuilderSkill
+from neurocore_skill_math.smt import Cvc5SmtCheckSkill, Z3SmtCheckSkill
+from neurocore_skill_math.symbolic import (
+    SympyCalculusSkill,
+    SympySimplifySkill,
+    SympySolveSkill,
+)
+
+__all__ = [
+    # Group 1 — prep
+    "MathProblemParserSkill",
+    "MathDomainClassifierSkill",
+    "MathStatementNormalizerSkill",
+    # Group 2 — symbolic / numeric / CAS
+    "SympySimplifySkill",
+    "SympySolveSkill",
+    "SympyCalculusSkill",
+    "MpmathHighPrecisionCheckSkill",
+    "SagemathComputeSkill",
+    "PariGpNumberTheorySkill",
+    "GapGroupTheorySkill",
+    # Group 3 — counterexample / SMT
+    "Z3SmtCheckSkill",
+    "Cvc5SmtCheckSkill",
+    "Mace4CountermodelSkill",
+    # Group 4 — ATP
+    "VampireProveTptpSkill",
+    "EproverProveTptpSkill",
+    "Prover9ProveSkill",
+    # Group 4/5 — planning, retrieval
+    "LlmProofPlannerSkill",
+    "TheoremRetrieverSkill",
+    # Group 5 — formalization
+    "Lean4FormalizeStatementSkill",
+    "Lean4CheckSkill",
+    "Lean4RepairSkill",
+    "IsabelleCheckTheorySkill",
+    "CoqCheckSkill",
+    # Group 6 — reporting
+    "ProofReportBuilderSkill",
+]

neurocore_skill_math/_availability.py

@@ -0,0 +1,51 @@
+"""Detect which math tools (CLIs and Python libs) are available at runtime.
+
+Skills use this to degrade gracefully when a backend is not installed, and the
+``python -m neurocore_skill_math.check`` command prints a full report.
+"""
+from __future__ import annotations
+
+import importlib.util
+import shutil
+
+# CLI executables expected on PATH (Ubuntu installer provides these).
+CLI_TOOLS: list[str] = [
+    "gp",        # PARI/GP
+    "gap",       # GAP
+    "sage",      # SageMath (or via docker)
+    "docker",    # for the SageMath container fallback
+    "z3",        # z3 CLI (the skill prefers the python binding)
+    "cvc5",      # cvc5 CLI
+    "vampire",
+    "eprover",
+    "prover9",
+    "mace4",
+    "lean",
+    "lake",
+    "isabelle",
+    "coqc",
+]
+
+# Python libraries used directly by skills.
+PY_LIBS: list[str] = ["sympy", "mpmath", "z3", "cvc5", "numpy", "scipy", "networkx"]
+
+
+def tool_available(name: str) -> bool:
+    """True if a CLI executable is on PATH."""
+    return shutil.which(name) is not None
+
+
+def lib_available(module: str) -> bool:
+    """True if a Python module can be imported."""
+    try:
+        return importlib.util.find_spec(module) is not None
+    except (ImportError, ValueError):
+        return False
+
+
+def availability_report() -> dict[str, dict[str, bool]]:
+    """Return {'cli': {tool: bool}, 'lib': {module: bool}}."""
+    return {
+        "cli": {t: tool_available(t) for t in CLI_TOOLS},
+        "lib": {m: lib_available(m) for m in PY_LIBS},
+    }

neurocore_skill_math/_base.py

@@ -0,0 +1,112 @@
+"""Shared base for all math skills.
+
+``MathSkill`` standardizes:
+- configurable IO keys (``input_key`` / ``output_key`` + extras), per the design doc;
+- a uniform **result envelope** every skill writes to context;
+- **availability detection** + graceful degradation (never crash the flow when a
+  backend tool/lib is missing);
+- **port** helpers so skills can drive graph routing.
+
+Concrete skills subclass this, set ``default_input_key`` / ``default_output_key`` /
+``required_tool`` / ``required_lib`` / ``tool_name``, and implement ``_compute``.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from flowengine import FlowContext
+from neurocore import AsyncSkill
+
+from neurocore_skill_math._availability import lib_available, tool_available
+
+# Envelope status values.
+STATUS_OK = "ok"
+STATUS_REFUTED = "refuted"
+STATUS_PROVED = "proved"
+STATUS_UNKNOWN = "unknown"
+STATUS_UNAVAILABLE = "tool_unavailable"
+STATUS_ERROR = "error"
+STATUS_TIMEOUT = "timeout"
+
+
+class MathSkill(AsyncSkill):
+    """Base class for math-toolchain skills (not registered itself)."""
+
+    # Subclasses override these.
+    default_input_key: str = "math.normalized"
+    default_output_key: str = "math.result"
+    required_tool: str | None = None  # CLI executable to check on PATH
+    required_lib: str | None = None  # importable module to check
+    tool_name: str = "math"
+
+    def init(self, config: dict[str, Any]) -> None:
+        super().init(config)
+        self.in_key: str = self.config.get("input_key", self.default_input_key)
+        self.out_key: str = self.config.get("output_key", self.default_output_key)
+        self.timeout: float = float(self.config.get("timeout_seconds", 30))
+
+    # -- availability ------------------------------------------------------
+    def is_available(self) -> bool:
+        tool_ok = not self.required_tool or tool_available(self.required_tool)
+        lib_ok = not self.required_lib or lib_available(self.required_lib)
+        return tool_ok and lib_ok
+
+    def health_check(self) -> bool:
+        return self.is_initialized and self.is_available()
+
+    # -- execution ---------------------------------------------------------
+    async def process(self, context: FlowContext) -> FlowContext:  # type: ignore[override]
+        if not self.is_available():
+            missing = self.required_tool or self.required_lib or self.tool_name
+            self._write(
+                context,
+                self.envelope(
+                    STATUS_UNAVAILABLE,
+                    available=False,
+                    error=f"{missing!r} is not installed; skill skipped.",
+                ),
+            )
+            self.port(context, "tool_unavailable")
+            return context
+
+        payload = context.get(self.in_key)
+        start = time.perf_counter()
+        try:
+            env = await self._compute(payload, context)
+        except Exception as exc:  # noqa: BLE001 — degrade, don't crash the flow
+            env = self.envelope(STATUS_ERROR, error=str(exc))
+        env.setdefault("duration_ms", round((time.perf_counter() - start) * 1000, 2))
+        self._write(context, env)
+        return context
+
+    async def _compute(self, payload: Any, context: FlowContext) -> dict[str, Any]:
+        """Run the skill's work and return a result envelope. May also set ports."""
+        raise NotImplementedError
+
+    # -- helpers -----------------------------------------------------------
+    def envelope(
+        self,
+        status: str,
+        *,
+        result: Any = None,
+        log: str = "",
+        error: str | None = None,
+        available: bool = True,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        return {
+            "status": status,
+            "tool": self.tool_name,
+            "available": available,
+            "result": result,
+            "log": log,
+            "error": error,
+            **extra,
+        }
+
+    def _write(self, context: FlowContext, env: dict[str, Any]) -> None:
+        context.set(self.out_key, env)
+
+    def port(self, context: FlowContext, name: str) -> None:
+        self.set_output_port(context, name)

neurocore_skill_math/_formats.py

@@ -0,0 +1,54 @@
+"""Assemble solver inputs (SMT-LIB, TPTP) from skill payloads.
+
+A payload may be a ready-made source string, or a structured dict carrying the
+source under a known key (``smtlib`` / ``tptp`` / ``prover9``). Skills accept both
+so an upstream LLM/normalizer can emit either form.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _coerce(payload: Any, *keys: str) -> str | None:
+    """Pull a source string out of a payload (raw string or dict with one of keys)."""
+    if isinstance(payload, str):
+        return payload
+    if hasattr(payload, "get"):  # dict / DotDict
+        for k in keys:
+            v = payload.get(k)
+            if isinstance(v, str) and v.strip():
+                return v
+    return None
+
+
+def as_smtlib(payload: Any) -> str | None:
+    """Return an SMT-LIB v2 script from the payload, or None if not provided.
+
+    Ensures a ``(check-sat)`` is present so the solver actually runs.
+    """
+    src = _coerce(payload, "smtlib", "smt", "source")
+    if src is None:
+        return None
+    if "(check-sat)" not in src:
+        src = src.rstrip() + "\n(check-sat)\n"
+    return src
+
+
+def as_tptp(payload: Any) -> str | None:
+    """Return a TPTP problem string from the payload, or None."""
+    return _coerce(payload, "tptp", "fof", "source")
+
+
+def as_prover9(payload: Any) -> str | None:
+    """Return a Prover9/Mace4 input deck from the payload, or None."""
+    return _coerce(payload, "prover9", "mace4", "source")
+
+
+def parse_smt_result(stdout: str) -> str:
+    """Map raw solver stdout to 'sat' | 'unsat' | 'unknown'."""
+    text = stdout.strip().lower()
+    if "unsat" in text:
+        return "unsat"
+    if "sat" in text:
+        return "sat"
+    return "unknown"

neurocore_skill_math/_llm.py

@@ -0,0 +1,54 @@
+"""Base for LLM-backed math skills (problem prep, planning, formalization)."""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from neurocore_skill_math._base import MathSkill
+
+_JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
+
+
+def extract_json(text: str) -> dict[str, Any]:
+    """Best-effort: parse the first JSON object in ``text``; else wrap as {'raw': ...}."""
+    match = _JSON_RE.search(text or "")
+    if match:
+        try:
+            obj = json.loads(match.group(0))
+            if isinstance(obj, dict):
+                return obj
+        except json.JSONDecodeError:
+            pass
+    return {"raw": (text or "").strip()}
+
+
+class LlmMathSkill(MathSkill):
+    """MathSkill whose backend is the injected LLM provider (`requires_llm=True`)."""
+
+    tool_name = "llm"
+
+    def is_available(self) -> bool:
+        return getattr(self, "llm", None) is not None
+
+    async def _ask(self, user: str, system: str | None = None) -> str:
+        from neurocore.llm.provider import LLMMessage
+
+        response = await self.llm.complete(
+            [LLMMessage(role="user", content=user)], system=system
+        )
+        return response.content
+
+    async def _ask_json(self, user: str, system: str | None = None) -> dict[str, Any]:
+        return extract_json(await self._ask(user, system))
+
+    @staticmethod
+    def _text(payload: Any, *keys: str) -> str:
+        if isinstance(payload, str):
+            return payload
+        if hasattr(payload, "get"):
+            for k in (*keys, "problem", "statement", "normalized", "raw"):
+                v = payload.get(k)
+                if isinstance(v, str) and v.strip():
+                    return v
+        return str(payload or "")

neurocore_skill_math/_run.py

@@ -0,0 +1,81 @@
+"""Subprocess helpers with timeouts for external math tools.
+
+Kept small and dependency-free. ``run_cli`` is the seam tests monkeypatch so the
+suite needs neither the real provers nor a network.
+"""
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class CliResult:
+    """Outcome of a CLI invocation."""
+
+    returncode: int
+    stdout: str
+    stderr: str
+    timed_out: bool = False
+
+
+def run_cli(
+    cmd: list[str],
+    *,
+    stdin: str | None = None,
+    timeout: float = 30.0,
+    env: dict[str, str] | None = None,
+    cwd: str | None = None,
+) -> CliResult:
+    """Run a command, capturing stdout/stderr, returning a CliResult.
+
+    A timeout yields ``timed_out=True`` (never raises); other OS errors surface
+    as a non-zero return code with the message on stderr.
+    """
+    try:
+        proc = subprocess.run(
+            cmd,
+            input=stdin,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env=env,
+            cwd=cwd,
+            check=False,
+        )
+        return CliResult(proc.returncode, proc.stdout, proc.stderr)
+    except subprocess.TimeoutExpired as exc:
+        out = exc.stdout or ""
+        err = exc.stderr or ""
+        out = out.decode() if isinstance(out, bytes) else out
+        err = err.decode() if isinstance(err, bytes) else err
+        return CliResult(-1, out, err, timed_out=True)
+    except OSError as exc:
+        return CliResult(-1, "", str(exc))
+
+
+def docker_cmd(
+    image: str,
+    args: list[str],
+    *,
+    network: bool = False,
+    memory: str | None = "4g",
+    cpus: str | None = "2",
+    mounts: list[tuple[str, str]] | None = None,
+    read_only: bool = True,
+) -> list[str]:
+    """Build a sandboxed ``docker run`` command (per design doc §C).
+
+    Defaults: no network, capped memory/cpus, read-only mounts.
+    """
+    cmd = ["docker", "run", "--rm"]
+    if not network:
+        cmd += ["--network", "none"]
+    if memory:
+        cmd += ["--memory", memory]
+    if cpus:
+        cmd += ["--cpus", cpus]
+    for src, dst in mounts or []:
+        cmd += ["-v", f"{src}:{dst}{':ro' if read_only else ''}"]
+    cmd += [image, *args]
+    return cmd

neurocore_skill_math/atp.py

@@ -0,0 +1,188 @@
+"""Group 3/4 — automated theorem provers and finite-model search.
+
+- ``vampire_prove_tptp`` / ``eprover_prove_tptp`` — first-order ATP on TPTP input.
+- ``prover9_prove`` — Prover9 (its own syntax).
+- ``mace4_countermodel`` — Mace4 finite-model search (counterexamples).
+
+Provers set port ``proof_found`` / ``no_proof``; Mace4 sets ``counterexample_found`` /
+``no_counterexample``.
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Any
+
+from flowengine import FlowContext
+from neurocore import SkillMeta
+
+from neurocore_skill_math._base import (
+    STATUS_ERROR,
+    STATUS_OK,
+    STATUS_PROVED,
+    STATUS_REFUTED,
+    STATUS_TIMEOUT,
+    STATUS_UNKNOWN,
+    MathSkill,
+)
+from neurocore_skill_math._formats import as_prover9, as_tptp
+from neurocore_skill_math._run import run_cli
+
+_TPTP_SCHEMA = {"properties": {
+    "input_key": {"type": "string"}, "output_key": {"type": "string"},
+    "premises_key": {"type": "string"}, "timeout_seconds": {"type": "integer"},
+}}
+
+
+def _szs_verdict(text: str) -> str:
+    """Map prover stdout (SZS ontology / common phrases) to proved/disproved/unknown."""
+    t = text.lower()
+    if ("refutation found" in t or "szs status theorem" in t
+            or "szs status unsatisfiable" in t or "proof found" in t
+            or "theorem proved" in t):
+        return "proved"
+    if ("countersatisfiable" in t or "szs status satisfiable" in t
+            or "search failed" in t):
+        return "disproved"
+    return "unknown"
+
+
+class _TptpProver(MathSkill):
+    default_input_key = "math.normalized"
+    cli: str = ""  # subclass sets the executable
+
+    def _write_tmp(self, content: str, suffix: str) -> str:
+        fd, path = tempfile.mkstemp(prefix="nc-atp-", suffix=suffix)
+        with os.fdopen(fd, "w") as fh:
+            fh.write(content)
+        return path
+
+    def _route_proof(self, context: FlowContext, verdict: str, log: str) -> dict[str, Any]:
+        if verdict == "proved":
+            self.port(context, "proof_found")
+            return self.envelope(STATUS_PROVED, result={"proof_found": True}, log=log[:4000])
+        self.port(context, "no_proof")
+        status = STATUS_OK if verdict == "disproved" else STATUS_UNKNOWN
+        return self.envelope(status, result={"proof_found": False, "verdict": verdict},
+                             log=log[:4000])
+
+
+class VampireProveTptpSkill(_TptpProver):
+    default_output_key = "proof.vampire"
+    required_tool = "vampire"
+    cli = "vampire"
+    tool_name = "vampire"
+
+    skill_meta = SkillMeta(
+        name="vampire_prove_tptp",
+        version="0.1.0",
+        description="Prove a TPTP first-order conjecture with Vampire.",
+        author="NeuroCore Contributors",
+        provides=["proof.vampire"], consumes=["math.normalized", "proof.premises"],
+        tags=["math", "atp", "tptp", "vampire"], config_schema=_TPTP_SCHEMA,
+    )
+
+    async def _compute(self, payload: Any, context: FlowContext) -> dict[str, Any]:
+        tptp = as_tptp(payload)
+        if not tptp:
+            return self.envelope(STATUS_ERROR, error="no TPTP input provided")
+        path = self._write_tmp(tptp, ".p")
+        res = run_cli(["vampire", "-t", str(int(self.timeout)), path], timeout=self.timeout + 5)
+        if res.timed_out:
+            self.port(context, "no_proof")
+            return self.envelope(STATUS_TIMEOUT, error="vampire timed out")
+        return self._route_proof(context, _szs_verdict(res.stdout), res.stdout)
+
+
+class EproverProveTptpSkill(_TptpProver):
+    default_output_key = "proof.eprover"
+    required_tool = "eprover"
+    cli = "eprover"
+    tool_name = "eprover"
+
+    skill_meta = SkillMeta(
+        name="eprover_prove_tptp",
+        version="0.1.0",
+        description="Prove a TPTP first-order conjecture with the E prover.",
+        author="NeuroCore Contributors",
+        provides=["proof.eprover"], consumes=["math.normalized", "proof.premises"],
+        tags=["math", "atp", "tptp", "eprover"], config_schema=_TPTP_SCHEMA,
+    )
+
+    async def _compute(self, payload: Any, context: FlowContext) -> dict[str, Any]:
+        tptp = as_tptp(payload)
+        if not tptp:
+            return self.envelope(STATUS_ERROR, error="no TPTP input provided")
+        path = self._write_tmp(tptp, ".p")
+        res = run_cli(
+            ["eprover", "--auto", "--tptp3-format", f"--cpu-limit={int(self.timeout)}", path],
+            timeout=self.timeout + 5,
+        )
+        if res.timed_out:
+            self.port(context, "no_proof")
+            return self.envelope(STATUS_TIMEOUT, error="eprover timed out")
+        return self._route_proof(context, _szs_verdict(res.stdout), res.stdout)
+
+
+class Prover9ProveSkill(_TptpProver):
+    default_output_key = "proof.prover9"
+    required_tool = "prover9"
+    cli = "prover9"
+    tool_name = "prover9"
+
+    skill_meta = SkillMeta(
+        name="prover9_prove",
+        version="0.1.0",
+        description="Prove a conjecture with Prover9 (Prover9 input syntax).",
+        author="NeuroCore Contributors",
+        provides=["proof.prover9"], consumes=["math.normalized", "proof.premises"],
+        tags=["math", "atp", "prover9"], config_schema=_TPTP_SCHEMA,
+    )
+
+    async def _compute(self, payload: Any, context: FlowContext) -> dict[str, Any]:
+        deck = as_prover9(payload)
+        if not deck:
+            return self.envelope(STATUS_ERROR, error="no Prover9 input provided")
+        res = run_cli(["prover9"], stdin=deck, timeout=self.timeout)
+        if res.timed_out:
+            self.port(context, "no_proof")
+            return self.envelope(STATUS_TIMEOUT, error="prover9 timed out")
+        return self._route_proof(context, _szs_verdict(res.stdout), res.stdout)
+
+
+class Mace4CountermodelSkill(MathSkill):
+    default_input_key = "math.normalized"
+    default_output_key = "counterexamples.mace4"
+    required_tool = "mace4"
+    tool_name = "mace4"
+
+    skill_meta = SkillMeta(
+        name="mace4_countermodel",
+        version="0.1.0",
+        description="Search for a finite countermodel with Mace4.",
+        author="NeuroCore Contributors",
+        provides=["counterexamples.mace4"], consumes=["math.normalized"],
+        tags=["math", "counterexample", "finite-model", "mace4"],
+        config_schema={"properties": {
+            "input_key": {"type": "string"}, "output_key": {"type": "string"},
+            "timeout_seconds": {"type": "integer"}, "max_domain_size": {"type": "integer"},
+        }},
+    )
+
+    async def _compute(self, payload: Any, context: FlowContext) -> dict[str, Any]:
+        deck = as_prover9(payload)
+        if not deck:
+            return self.envelope(STATUS_ERROR, error="no Mace4 input provided")
+        n = int(self.config.get("max_domain_size", 8))
+        res = run_cli(["mace4", "-n", str(n)], stdin=deck, timeout=self.timeout)
+        if res.timed_out:
+            self.port(context, "no_counterexample")
+            return self.envelope(STATUS_TIMEOUT, error="mace4 timed out")
+        found = "model" in res.stdout.lower() and "exiting with" in res.stdout.lower()
+        if found:
+            self.port(context, "counterexample_found")
+            return self.envelope(STATUS_REFUTED, result={"countermodel": res.stdout.strip()},
+                                 counterexample_found=True)
+        self.port(context, "no_counterexample")
+        return self.envelope(STATUS_OK, result={"countermodel": None},
+                             counterexample_found=False)