neurocore-skill-math 0.1.0__tar.gz

neurocore_skill_math-0.1.0/.gitignore

@@ -0,0 +1,152 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Ruff
+.ruff_cache/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db

neurocore_skill_math-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: neurocore-skill-math
+Version: 0.1.0
+Summary: Math-proof toolchain skills for NeuroCore: CAS, SMT, ATP, and formal proof assistants
+Author: NeuroCore Contributors
+License-Expression: Apache-2.0
+Keywords: ai,lean,math,neurocore,proof,skill,sympy,theorem-proving,z3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: mpmath>=1.3
+Requires-Dist: neurocore-ai>=0.4.0
+Requires-Dist: sympy>=1.12
+Requires-Dist: z3-solver>=4.12
+Provides-Extra: cvc5
+Requires-Dist: cvc5>=1.1; extra == 'cvc5'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: numeric
+Requires-Dist: networkx>=3.0; extra == 'numeric'
+Requires-Dist: numpy>=1.26; extra == 'numeric'
+Requires-Dist: scipy>=1.11; extra == 'numeric'
+Description-Content-Type: text/markdown
+
+# neurocore-skill-math
+
+A **math-proof toolchain** for [NeuroCore](https://github.com/alexh-scrt/neurocore):
+one package exposing many small, composable skills that wrap computer-algebra
+systems, SMT solvers, automated theorem provers, and formal proof assistants. A
+supervisor agent / FlowEngine blueprint composes them into proof-search and
+proof-validation chains.
+
+```bash
+pip install neurocore-skill-math          # pulls sympy, mpmath, z3-solver
+pip install "neurocore-skill-math[cvc5]"  # + cvc5 SMT backend (optional)
+```
+
+Most external engines (Lean, Vampire, Isabelle, Coq, SageMath, GAP, PARI/GP, …)
+are **not** Python packages — install them with the provided script
+(`scripts/install_math_tools.sh`, Ubuntu 24.04) and check what's available:
+
+```bash
+python -m neurocore_skill_math.check      # prints a tool-availability report
+```
+
+Every skill **detects whether its backend is installed** and degrades gracefully
+(status `tool_unavailable`) rather than crashing a flow.
+
+## Skills
+
+| `type` | Group | Backend | Reads → writes |
+|--------|-------|---------|----------------|
+| `math_problem_parser` | prep | LLM | `problem` → `math.parsed` |
+| `math_domain_classifier` | prep | LLM | `math.parsed` → `math.domain` |
+| `math_statement_normalizer` | prep | LLM | `math.parsed` → `math.normalized` |
+| `sympy_simplify` / `sympy_solve` / `sympy_calculus` | symbolic | SymPy | `math.normalized` → `evidence.sympy` |
+| `mpmath_high_precision_check` | numeric | mpmath | `math.normalized` → `evidence.numeric` |
+| `pari_gp_number_theory` | CAS | `gp` | `math.normalized` → `evidence.pari` |
+| `gap_group_theory` | CAS | `gap` | `math.normalized` → `evidence.gap` |
+| `sagemath_compute` | CAS | `sage`/Docker | `math.normalized` → `evidence.sage` |
+| `z3_smt_check` | SMT | z3 | `math.normalized` → `counterexamples.z3` |
+| `cvc5_smt_check` | SMT | cvc5 | `math.normalized` → `counterexamples.cvc5` |
+| `mace4_countermodel` | counterexample | `mace4` | `math.normalized` → `counterexamples.mace4` |
+| `vampire_prove_tptp` / `eprover_prove_tptp` | ATP | `vampire`/`eprover` | `math.normalized` → `proof.*` |
+| `prover9_prove` | ATP | `prover9` | `math.normalized` → `proof.prover9` |
+| `llm_proof_planner` | planning | LLM | evidence → `proof.strategy` |
+| `theorem_retriever` | planning | LLM | `proof.strategy` → `proof.premises` |
+| `lean4_formalize_statement` | formal | LLM | `math.normalized` → `formal.lean_candidate` |
+| `lean4_check` | formal | `lean`/`lake` | `formal.lean_candidate` → `formal.lean_result` |
+| `lean4_repair` | formal | LLM | `formal.lean_candidate` + errors → `formal.lean_candidate` |
+| `isabelle_check_theory` | formal | `isabelle` | `formal.isabelle_candidate` → `formal.isabelle_result` |
+| `coq_check` | formal | `coqc` | `formal.coq_candidate` → `formal.coq_result` |
+| `proof_report_builder` | report | — | all envelopes → `validation_status` / `final_answer` / `proof_artifacts` |
+
+### Result envelope & ports
+
+Each skill writes a uniform envelope:
+`{status, tool, available, result, log, error, duration_ms}` with
+`status ∈ {ok, proved, refuted, unknown, tool_unavailable, error, timeout}`.
+
+Skills set **output ports** so graph blueprints can route:
+- SMT / Mace4: `counterexample_found` / `no_counterexample`
+- ATP: `proof_found` / `no_proof`
+- Lean/Isabelle/Coq check: `verified` / `repair_needed` / `failed`
+- domain classifier: `number_theory` / `group_theory` / …
+
+All skills take configurable `input_key` / `output_key` (the doc's dotted-key
+contract, e.g. `evidence.sympy`), so the same skill can be wired into different
+positions in a chain.
+
+## Blueprints
+
+`blueprints/` ships two reference proof workers from the design:
+- `lean-first-math-worker.flow.yaml` — a focused parse → explore → refute →
+  formalize → verify → repair → report loop.
+- `math-proof-validation-worker.flow.yaml` — the full fan-out across CAS/SMT/ATP
+  then Lean/Isabelle/Coq validation.
+
+> **Graph routing.** These workers use edge **ports**, edge **conditions**, and a
+> Lean **repair loop**. With `neurocore-ai>=0.4.0` (on `flowengine>=0.6.0`),
+> NeuroCore routes such graph flows through flowengine's `GraphExecutor`, which
+> honors port/condition gating and cyclic `max_iterations` — so the conditional
+> early-exits and the repair loop execute as drawn. Plain DAGs (no
+> ports/conditions/cycles) still use the concurrent layer executor. On older
+> NeuroCore the skills' ports are simply ignored (all reachable nodes run).
+
+## Convention
+
+Standard NeuroCore skill package: entry-point group `neurocore.skills`, import
+package `neurocore_skill_math`, kebab distribution `neurocore-skill-math`. See the
+[skill-authoring guide](https://neurocore.readthedocs.io/skill-authoring.html).

neurocore_skill_math-0.1.0/README.md

@@ -0,0 +1,87 @@
+# neurocore-skill-math
+
+A **math-proof toolchain** for [NeuroCore](https://github.com/alexh-scrt/neurocore):
+one package exposing many small, composable skills that wrap computer-algebra
+systems, SMT solvers, automated theorem provers, and formal proof assistants. A
+supervisor agent / FlowEngine blueprint composes them into proof-search and
+proof-validation chains.
+
+```bash
+pip install neurocore-skill-math          # pulls sympy, mpmath, z3-solver
+pip install "neurocore-skill-math[cvc5]"  # + cvc5 SMT backend (optional)
+```
+
+Most external engines (Lean, Vampire, Isabelle, Coq, SageMath, GAP, PARI/GP, …)
+are **not** Python packages — install them with the provided script
+(`scripts/install_math_tools.sh`, Ubuntu 24.04) and check what's available:
+
+```bash
+python -m neurocore_skill_math.check      # prints a tool-availability report
+```
+
+Every skill **detects whether its backend is installed** and degrades gracefully
+(status `tool_unavailable`) rather than crashing a flow.
+
+## Skills
+
+| `type` | Group | Backend | Reads → writes |
+|--------|-------|---------|----------------|
+| `math_problem_parser` | prep | LLM | `problem` → `math.parsed` |
+| `math_domain_classifier` | prep | LLM | `math.parsed` → `math.domain` |
+| `math_statement_normalizer` | prep | LLM | `math.parsed` → `math.normalized` |
+| `sympy_simplify` / `sympy_solve` / `sympy_calculus` | symbolic | SymPy | `math.normalized` → `evidence.sympy` |
+| `mpmath_high_precision_check` | numeric | mpmath | `math.normalized` → `evidence.numeric` |
+| `pari_gp_number_theory` | CAS | `gp` | `math.normalized` → `evidence.pari` |
+| `gap_group_theory` | CAS | `gap` | `math.normalized` → `evidence.gap` |
+| `sagemath_compute` | CAS | `sage`/Docker | `math.normalized` → `evidence.sage` |
+| `z3_smt_check` | SMT | z3 | `math.normalized` → `counterexamples.z3` |
+| `cvc5_smt_check` | SMT | cvc5 | `math.normalized` → `counterexamples.cvc5` |
+| `mace4_countermodel` | counterexample | `mace4` | `math.normalized` → `counterexamples.mace4` |
+| `vampire_prove_tptp` / `eprover_prove_tptp` | ATP | `vampire`/`eprover` | `math.normalized` → `proof.*` |
+| `prover9_prove` | ATP | `prover9` | `math.normalized` → `proof.prover9` |
+| `llm_proof_planner` | planning | LLM | evidence → `proof.strategy` |
+| `theorem_retriever` | planning | LLM | `proof.strategy` → `proof.premises` |
+| `lean4_formalize_statement` | formal | LLM | `math.normalized` → `formal.lean_candidate` |
+| `lean4_check` | formal | `lean`/`lake` | `formal.lean_candidate` → `formal.lean_result` |
+| `lean4_repair` | formal | LLM | `formal.lean_candidate` + errors → `formal.lean_candidate` |
+| `isabelle_check_theory` | formal | `isabelle` | `formal.isabelle_candidate` → `formal.isabelle_result` |
+| `coq_check` | formal | `coqc` | `formal.coq_candidate` → `formal.coq_result` |
+| `proof_report_builder` | report | — | all envelopes → `validation_status` / `final_answer` / `proof_artifacts` |
+
+### Result envelope & ports
+
+Each skill writes a uniform envelope:
+`{status, tool, available, result, log, error, duration_ms}` with
+`status ∈ {ok, proved, refuted, unknown, tool_unavailable, error, timeout}`.
+
+Skills set **output ports** so graph blueprints can route:
+- SMT / Mace4: `counterexample_found` / `no_counterexample`
+- ATP: `proof_found` / `no_proof`
+- Lean/Isabelle/Coq check: `verified` / `repair_needed` / `failed`
+- domain classifier: `number_theory` / `group_theory` / …
+
+All skills take configurable `input_key` / `output_key` (the doc's dotted-key
+contract, e.g. `evidence.sympy`), so the same skill can be wired into different
+positions in a chain.
+
+## Blueprints
+
+`blueprints/` ships two reference proof workers from the design:
+- `lean-first-math-worker.flow.yaml` — a focused parse → explore → refute →
+  formalize → verify → repair → report loop.
+- `math-proof-validation-worker.flow.yaml` — the full fan-out across CAS/SMT/ATP
+  then Lean/Isabelle/Coq validation.
+
+> **Graph routing.** These workers use edge **ports**, edge **conditions**, and a
+> Lean **repair loop**. With `neurocore-ai>=0.4.0` (on `flowengine>=0.6.0`),
+> NeuroCore routes such graph flows through flowengine's `GraphExecutor`, which
+> honors port/condition gating and cyclic `max_iterations` — so the conditional
+> early-exits and the repair loop execute as drawn. Plain DAGs (no
+> ports/conditions/cycles) still use the concurrent layer executor. On older
+> NeuroCore the skills' ports are simply ignored (all reachable nodes run).
+
+## Convention
+
+Standard NeuroCore skill package: entry-point group `neurocore.skills`, import
+package `neurocore_skill_math`, kebab distribution `neurocore-skill-math`. See the
+[skill-authoring guide](https://neurocore.readthedocs.io/skill-authoring.html).

neurocore_skill_math-0.1.0/blueprints/lean-first-math-worker.flow.yaml

@@ -0,0 +1,90 @@
+# lean-first-math-worker — a focused proof-validation loop (design doc §6).
+#
+#   parse → (sympy explore + z3 counterexample) → plan → retrieve premises
+#         → formalize in Lean → check → (repair loop) → report
+#
+# Run:
+#   neurocore run blueprints/lean-first-math-worker.flow.yaml \
+#     --data problem="Every integer n > 1 has a prime divisor."
+#
+# ROUTING: with neurocore-ai>=0.4.0 (flowengine>=0.6.0), graph flows that use
+# edge ports/conditions or cycles route through flowengine's GraphExecutor, so the
+# z3 counterexample early-exit and the lean check→repair loop execute as drawn.
+# LLM skills require an `llm:` provider in neurocore.yaml; unavailable external
+# tools degrade to status=tool_unavailable (run `python -m neurocore_skill_math.check`).
+name: lean-first-math-worker
+version: "0.1.0"
+description: >
+  Parse a problem, explore with SymPy, search for a counterexample with Z3, plan a
+  proof, retrieve premises, formalize and check in Lean 4 (with a repair loop), and
+  emit a proof report.
+components:
+  - name: parse
+    type: math_problem_parser
+    config: {input_key: problem, output_key: math.parsed}
+  - name: sympy
+    type: sympy_simplify
+    config: {input_key: math.parsed, output_key: evidence.sympy, timeout_seconds: 15}
+  - name: z3
+    type: z3_smt_check
+    config: {input_key: math.parsed, output_key: counterexamples.z3, timeout_seconds: 20}
+  - name: planner
+    type: llm_proof_planner
+    config: {input_key: math.parsed, output_key: proof.strategy}
+  - name: retrieve
+    type: theorem_retriever
+    config: {input_key: proof.strategy, output_key: proof.premises, backends: [lean_mathlib]}
+  - name: formalize
+    type: lean4_formalize_statement
+    config:
+      input_key: math.parsed
+      strategy_key: proof.strategy
+      premises_key: proof.premises
+      output_key: formal.lean_candidate
+  - name: check
+    type: lean4_check
+    config:
+      input_key: formal.lean_candidate
+      output_key: formal.lean_result
+      project_root: ./lean/MathAgent
+      timeout_seconds: 120
+  - name: repair
+    type: lean4_repair
+    config:
+      candidate_key: formal.lean_candidate
+      error_key: formal.lean_result
+      output_key: formal.lean_candidate
+      max_repair_attempts: 3
+  - name: report
+    type: proof_report_builder
+    config: {input_key: math.parsed}
+flow:
+  type: graph
+  settings:
+    max_iterations: 3
+    on_max_iterations: exit
+    timeout_seconds: 300
+    fail_fast: false
+  nodes:
+    - {id: parse, component: parse}
+    - {id: sympy, component: sympy}
+    - {id: z3, component: z3}
+    - {id: planner, component: planner}
+    - {id: retrieve, component: retrieve}
+    - {id: formalize, component: formalize}
+    - {id: check, component: check}
+    - {id: repair, component: repair}
+    - {id: report, component: report}
+  edges:
+    - {source: parse, target: sympy}
+    - {source: parse, target: z3}
+    - {source: z3, target: report, port: counterexample_found}
+    - {source: sympy, target: planner}
+    - {source: z3, target: planner, port: no_counterexample}
+    - {source: planner, target: retrieve}
+    - {source: retrieve, target: formalize}
+    - {source: formalize, target: check}
+    - {source: check, target: report, port: verified}
+    - {source: check, target: repair, port: repair_needed}
+    - {source: repair, target: check, port: repaired}
+    - {source: check, target: report, port: failed}

neurocore_skill_math-0.1.0/blueprints/math-proof-validation-worker.flow.yaml

@@ -0,0 +1,116 @@
+# math-proof-validation-worker — the full proof toolchain (design doc §5).
+#
+#   parse → classify → normalize
+#         → fan-out: sympy / sage / pari / gap / numeric / z3 / cvc5 / mace4
+#         → plan → retrieve premises
+#         → ATP: vampire / eprover / prover9
+#         → formalize in Lean → check (+ isabelle/coq checks) → repair loop
+#         → report
+#
+# Run:
+#   neurocore run blueprints/math-proof-validation-worker.flow.yaml \
+#     --data problem="<your statement>" --project-root <project-with-llm-config>
+#
+# ROUTING: with neurocore-ai>=0.4.0 (flowengine>=0.6.0), this graph routes through
+# flowengine's GraphExecutor, which honors edge ports/conditions and cyclic
+# max_iterations — so the early counterexample exits and the Lean repair loop
+# execute as drawn. Heavy backends degrade to status=tool_unavailable when not
+# installed (run `python -m neurocore_skill_math.check`). LLM skills need an
+# `llm:` provider configured in neurocore.yaml.
+name: math-proof-validation-worker
+version: "0.1.0"
+description: >
+  Explore, search for counterexamples, attempt proof search, formalize candidate
+  proofs, validate them with proof assistants, and emit a proof report.
+components:
+  - {name: parse, type: math_problem_parser, config: {input_key: problem, output_key: math.parsed}}
+  - {name: classify, type: math_domain_classifier, config: {input_key: math.parsed, output_key: math.domain}}
+  - {name: normalize, type: math_statement_normalizer, config: {input_key: math.parsed, domain_key: math.domain, output_key: math.normalized}}
+  - {name: sympy, type: sympy_simplify, config: {input_key: math.normalized, output_key: evidence.sympy, timeout_seconds: 15}}
+  - {name: sage, type: sagemath_compute, config: {input_key: math.normalized, output_key: evidence.sage, timeout_seconds: 60}}
+  - {name: pari, type: pari_gp_number_theory, config: {input_key: math.normalized, output_key: evidence.pari, timeout_seconds: 20}}
+  - {name: gap, type: gap_group_theory, config: {input_key: math.normalized, output_key: evidence.gap, timeout_seconds: 20}}
+  - {name: numeric, type: mpmath_high_precision_check, config: {input_key: math.normalized, output_key: evidence.numeric, precision_digits: 100, timeout_seconds: 20}}
+  - {name: z3, type: z3_smt_check, config: {input_key: math.normalized, output_key: counterexamples.z3, timeout_seconds: 20}}
+  - {name: cvc5, type: cvc5_smt_check, config: {input_key: math.normalized, output_key: counterexamples.cvc5, timeout_seconds: 20}}
+  - {name: mace4, type: mace4_countermodel, config: {input_key: math.normalized, output_key: counterexamples.mace4, timeout_seconds: 30, max_domain_size: 8}}
+  - {name: plan, type: llm_proof_planner, config: {input_key: math.normalized, output_key: proof.strategy}}
+  - {name: retrieve, type: theorem_retriever, config: {input_key: proof.strategy, output_key: proof.premises, backends: [lean_mathlib, isabelle_afp]}}
+  - {name: vampire, type: vampire_prove_tptp, config: {input_key: math.normalized, premises_key: proof.premises, output_key: proof.vampire, timeout_seconds: 30}}
+  - {name: eprover, type: eprover_prove_tptp, config: {input_key: math.normalized, premises_key: proof.premises, output_key: proof.eprover, timeout_seconds: 30}}
+  - {name: prover9, type: prover9_prove, config: {input_key: math.normalized, premises_key: proof.premises, output_key: proof.prover9, timeout_seconds: 30}}
+  - {name: lean_formalize, type: lean4_formalize_statement, config: {input_key: math.normalized, strategy_key: proof.strategy, premises_key: proof.premises, output_key: formal.lean_candidate}}
+  - {name: lean_check, type: lean4_check, config: {input_key: formal.lean_candidate, output_key: formal.lean_result, project_root: ./lean/MathAgent, timeout_seconds: 120}}
+  - {name: lean_repair, type: lean4_repair, config: {candidate_key: formal.lean_candidate, error_key: formal.lean_result, output_key: formal.lean_candidate, max_repair_attempts: 3}}
+  - {name: isabelle_check, type: isabelle_check_theory, config: {input_key: formal.isabelle_candidate, output_key: formal.isabelle_result, timeout_seconds: 180}}
+  - {name: coq_check, type: coq_check, config: {input_key: formal.coq_candidate, output_key: formal.coq_result, timeout_seconds: 180}}
+  - {name: report, type: proof_report_builder, config: {input_key: math.normalized}}
+flow:
+  type: graph
+  settings:
+    max_iterations: 4
+    on_max_iterations: exit
+    timeout_seconds: 600
+    fail_fast: false
+  nodes:
+    - {id: parse, component: parse}
+    - {id: classify, component: classify}
+    - {id: normalize, component: normalize}
+    - {id: sympy, component: sympy}
+    - {id: sage, component: sage}
+    - {id: pari, component: pari}
+    - {id: gap, component: gap}
+    - {id: numeric, component: numeric}
+    - {id: z3, component: z3}
+    - {id: cvc5, component: cvc5}
+    - {id: mace4, component: mace4}
+    - {id: plan, component: plan}
+    - {id: retrieve, component: retrieve}
+    - {id: vampire, component: vampire}
+    - {id: eprover, component: eprover}
+    - {id: prover9, component: prover9}
+    - {id: lean_formalize, component: lean_formalize}
+    - {id: lean_check, component: lean_check}
+    - {id: lean_repair, component: lean_repair}
+    - {id: isabelle_check, component: isabelle_check}
+    - {id: coq_check, component: coq_check}
+    - {id: report, component: report}
+  edges:
+    - {source: parse, target: classify}
+    - {source: classify, target: normalize}
+    # Exploration + counterexample fan-out.
+    - {source: normalize, target: sympy}
+    - {source: normalize, target: sage}
+    - {source: normalize, target: pari, port: number_theory}
+    - {source: normalize, target: gap, port: group_theory}
+    - {source: normalize, target: numeric}
+    - {source: normalize, target: z3}
+    - {source: normalize, target: cvc5}
+    - {source: normalize, target: mace4}
+    # Early refutation.
+    - {source: z3, target: report, port: counterexample_found}
+    - {source: cvc5, target: report, port: counterexample_found}
+    - {source: mace4, target: report, port: counterexample_found}
+    # Otherwise plan + retrieve.
+    - {source: sympy, target: plan}
+    - {source: numeric, target: plan}
+    - {source: z3, target: plan, port: no_counterexample}
+    - {source: plan, target: retrieve}
+    # ATP attempts.
+    - {source: retrieve, target: vampire}
+    - {source: retrieve, target: eprover}
+    - {source: retrieve, target: prover9}
+    # Formalization + validation.
+    - {source: vampire, target: lean_formalize, port: proof_found}
+    - {source: eprover, target: lean_formalize, port: proof_found}
+    - {source: prover9, target: lean_formalize, port: proof_found}
+    - {source: retrieve, target: lean_formalize}
+    - {source: lean_formalize, target: lean_check}
+    - {source: lean_formalize, target: isabelle_check}
+    - {source: lean_formalize, target: coq_check}
+    - {source: lean_check, target: report, port: verified}
+    - {source: lean_check, target: lean_repair, port: repair_needed}
+    - {source: lean_repair, target: lean_check, port: repaired}
+    - {source: lean_check, target: report, port: failed}
+    - {source: isabelle_check, target: report}
+    - {source: coq_check, target: report}

neurocore_skill_math-0.1.0/pyproject.toml

@@ -0,0 +1,98 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "neurocore-skill-math"
+version = "0.1.0"
+description = "Math-proof toolchain skills for NeuroCore: CAS, SMT, ATP, and formal proof assistants"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.13"
+authors = [{ name = "NeuroCore Contributors" }]
+keywords = ["neurocore", "skill", "math", "proof", "sympy", "z3", "lean", "theorem-proving", "ai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "neurocore-ai>=0.4.0",
+    "sympy>=1.12",
+    "mpmath>=1.3",
+    "z3-solver>=4.12",
+]
+
+[project.optional-dependencies]
+# Optional backends; the matching skills detect availability and degrade gracefully.
+cvc5 = ["cvc5>=1.1"]
+numeric = ["numpy>=1.26", "scipy>=1.11", "networkx>=3.0"]
+dev = ["pytest>=9.0.2", "pytest-asyncio>=0.24", "ruff>=0.8", "mypy>=1.8"]
+
+[project.entry-points."neurocore.skills"]
+# Group 1 — problem preparation (LLM)
+math_problem_parser = "neurocore_skill_math:MathProblemParserSkill"
+math_domain_classifier = "neurocore_skill_math:MathDomainClassifierSkill"
+math_statement_normalizer = "neurocore_skill_math:MathStatementNormalizerSkill"
+# Group 2 — symbolic / numeric / CAS
+sympy_simplify = "neurocore_skill_math:SympySimplifySkill"
+sympy_solve = "neurocore_skill_math:SympySolveSkill"
+sympy_calculus = "neurocore_skill_math:SympyCalculusSkill"
+mpmath_high_precision_check = "neurocore_skill_math:MpmathHighPrecisionCheckSkill"
+sagemath_compute = "neurocore_skill_math:SagemathComputeSkill"
+pari_gp_number_theory = "neurocore_skill_math:PariGpNumberTheorySkill"
+gap_group_theory = "neurocore_skill_math:GapGroupTheorySkill"
+# Group 3 — counterexample / SMT
+z3_smt_check = "neurocore_skill_math:Z3SmtCheckSkill"
+cvc5_smt_check = "neurocore_skill_math:Cvc5SmtCheckSkill"
+mace4_countermodel = "neurocore_skill_math:Mace4CountermodelSkill"
+# Group 4 — automated proof search (ATP)
+vampire_prove_tptp = "neurocore_skill_math:VampireProveTptpSkill"
+eprover_prove_tptp = "neurocore_skill_math:EproverProveTptpSkill"
+prover9_prove = "neurocore_skill_math:Prover9ProveSkill"
+# Group 4/5 — planning, retrieval (LLM)
+llm_proof_planner = "neurocore_skill_math:LlmProofPlannerSkill"
+theorem_retriever = "neurocore_skill_math:TheoremRetrieverSkill"
+# Group 5 — formalization (Lean / Isabelle / Coq)
+lean4_formalize_statement = "neurocore_skill_math:Lean4FormalizeStatementSkill"
+lean4_check = "neurocore_skill_math:Lean4CheckSkill"
+lean4_repair = "neurocore_skill_math:Lean4RepairSkill"
+isabelle_check_theory = "neurocore_skill_math:IsabelleCheckTheorySkill"
+coq_check = "neurocore_skill_math:CoqCheckSkill"
+# Group 6 — reporting
+proof_report_builder = "neurocore_skill_math:ProofReportBuilderSkill"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/neurocore_skill_math"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/neurocore_skill_math/", "tests/", "blueprints/", "scripts/", "README.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+target-version = "py313"
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP", "B", "C4", "SIM"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+# Compact one-line setup (`ctx = FlowContext(); ctx.set(...)`) is fine in tests.
+"tests/*" = ["E702"]
+
+[tool.mypy]
+python_version = "3.13"
+# Math backends (sympy/mpmath/z3/cvc5) ship no type stubs.
+ignore_missing_imports = true
+disable_error_code = ["import-untyped"]