@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/math/lean-theorem-proving-guide/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: lean-theorem-proving-guide
+description: "LLM agent for formal theorem proving in Lean 4"
+metadata:
+  openclaw:
+    emoji: "📐"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["Lean 4", "theorem proving", "formal verification", "LLM math", "proof assistant", "LeanAgent"]
+    source: "https://github.com/lean-dojo/LeanAgent"
+---
+
+# Lean Theorem Proving Agent Guide
+
+## Overview
+
+LeanAgent is an LLM-based agent for automated theorem proving in Lean 4, a modern proof assistant. It combines LLM reasoning with formal verification — proposing proof steps that are verified by Lean's type checker. Can prove novel theorems, not just benchmarks, by exploring proof strategies, backtracking on failures, and learning from successful proofs.
+
+## Architecture
+
+```
+Theorem Statement (Lean 4)
+         ↓
+   Goal Analysis Agent (understand proof obligations)
+         ↓
+   Tactic Suggestion Agent (propose proof steps)
+         ↓
+   Lean 4 Verification (check tactic correctness)
+         ↓
+   Backtracking (if tactic fails, try alternatives)
+         ↓
+   Proof or timeout
+```
+
+## Usage
+
+```python
+from lean_agent import LeanAgent
+
+agent = LeanAgent(
+    llm_provider="anthropic",
+    lean_path="/path/to/lean4",
+)
+
+# Prove a theorem
+result = agent.prove(
+    theorem="""
+    theorem add_comm (m n : Nat) : m + n = n + m := by
+      sorry
+    """,
+    max_attempts=50,
+    timeout=120,
+)
+
+if result.proved:
+    print("Proof found!")
+    print(result.proof)
+else:
+    print(f"Failed. Best attempt:\n{result.best_attempt}")
+    print(f"Remaining goals: {result.remaining_goals}")
+```
+
+## Proof Search Strategies
+
+```python
+# Configure search strategy
+agent = LeanAgent(
+    search_config={
+        "strategy": "best_first",   # best_first, bfs, dfs
+        "max_depth": 20,            # Max proof steps
+        "beam_width": 5,            # Tactics to try per step
+        "temperature": 0.7,         # LLM sampling temp
+        "backtrack_on_fail": True,
+    },
+)
+
+# Interactive proof mode
+session = agent.interactive_prove(
+    theorem="theorem my_thm : ∀ n : Nat, n + 0 = n := by"
+)
+
+while not session.done:
+    print(f"Current goals:\n{session.goals}")
+    tactics = session.suggest_tactics(k=5)
+    for i, t in enumerate(tactics):
+        print(f"  {i}: {t.tactic} (confidence: {t.score:.2f})")
+    # Agent automatically picks best tactic
+    session.step()
+```
+
+## Lean 4 Tactic Library
+
+```lean
+-- Common tactics LeanAgent uses:
+-- intro, apply, exact, rfl, simp, omega
+-- induction, cases, constructor, ext
+-- rw, calc, have, let, show
+
+-- Example theorem + proof
+theorem list_append_nil (l : List α) : l ++ [] = l := by
+  induction l with
+  | nil => simp
+  | cons h t ih => simp [ih]
+```
+
+## Batch Proving
+
+```python
+# Prove multiple theorems
+theorems = [
+    "theorem t1 : 1 + 1 = 2 := by sorry",
+    "theorem t2 (n : Nat) : n + 0 = n := by sorry",
+    "theorem t3 (n m : Nat) : n + m = m + n := by sorry",
+]
+
+results = agent.prove_batch(
+    theorems=theorems,
+    parallel=True,
+    timeout_per=60,
+)
+
+for thm, result in zip(theorems, results):
+    status = "PROVED" if result.proved else "FAILED"
+    print(f"[{status}] {thm[:50]}...")
+```
+
+## Use Cases
+
+1. **Automated proving**: Prove mathematical theorems formally
+2. **Proof assistance**: Suggest tactics during manual proving
+3. **Verification**: Formally verify mathematical claims
+4. **Education**: Learn Lean 4 tactics with AI guidance
+5. **Research**: Explore new proof techniques
+
+## References
+
+- [LeanAgent GitHub](https://github.com/lean-dojo/LeanAgent)
+- [Lean 4](https://lean-lang.org/)
+- [Mathlib4](https://leanprover-community.github.io/mathlib4_docs/)
+- [LeanDojo](https://leandojo.org/)

package/skills/domains/math/symbolic-computation-guide/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: symbolic-computation-guide
+description: "Computer algebra systems: SymPy, SageMath, and Mathematica for research"
+metadata:
+  openclaw:
+    emoji: "abacus"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["symbolic-computation", "computer-algebra", "sympy", "sagemath", "mathematica", "calculus"]
+    source: "wentor"
+---
+
+# Symbolic Computation Guide
+
+A skill for using computer algebra systems (CAS) in mathematical research. Covers symbolic differentiation, integration, equation solving, series expansion, linear algebra, and polynomial arithmetic using SymPy, SageMath, and Mathematica, with practical workflows for research mathematics.
+
+## SymPy Fundamentals
+
+### Symbolic Expressions and Manipulation
+
+```python
+from sympy import (
+    symbols, expand, factor, simplify, cancel, apart,
+    sin, cos, exp, log, sqrt, pi, oo, I,
+    Rational, Eq, solve, solveset, S
+)
+
+x, y, z, t, n, k = symbols("x y z t n k")
+a, b, c = symbols("a b c", real=True)
+
+# Expression manipulation
+expr = (x + 1) ** 3
+expanded = expand(expr)       # x**3 + 3*x**2 + 3*x + 1
+factored = factor(expanded)   # (x + 1)**3
+
+# Trigonometric simplification
+from sympy import trigsimp
+trig_expr = sin(x)**2 + cos(x)**2
+simplified = trigsimp(trig_expr)  # 1
+
+# Partial fraction decomposition
+rational = (x**2 + 2*x + 3) / ((x + 1) * (x + 2) * (x + 3))
+partial = apart(rational, x)
+# 3/(2*(x + 3)) - 2/(x + 2) + 1/(2*(x + 1))
+```
+
+### Calculus
+
+```python
+from sympy import diff, integrate, limit, series, Sum, Product
+
+# Differentiation
+f = x**3 * exp(-x) * sin(x)
+f_prime = diff(f, x)
+f_double_prime = diff(f, x, 2)
+
+# Integration
+# Definite integral
+area = integrate(exp(-x**2), (x, -oo, oo))  # sqrt(pi)
+
+# Indefinite integral
+antideriv = integrate(x * sin(x), x)  # -x*cos(x) + sin(x)
+
+# Limits
+lim_result = limit(sin(x) / x, x, 0)  # 1
+lim_inf = limit((1 + 1/n)**n, n, oo)   # E (Euler's number)
+
+# Taylor series
+taylor = series(exp(x) * cos(x), x, 0, n=6)
+# 1 + x - x**3/3 - x**4/6 + ...
+
+# Summation
+harmonic = Sum(1/k, (k, 1, n))
+partial_sum = harmonic.doit()  # harmonic(n) -- returns harmonic number
+
+geometric = Sum(x**k, (k, 0, oo))
+closed_form = geometric.doit()  # Piecewise(1/(1 - x), Abs(x) < 1)
+```
+
+### Equation Solving
+
+```python
+# Algebraic equations
+solutions = solve(x**3 - 6*x**2 + 11*x - 6, x)  # [1, 2, 3]
+
+# System of equations
+system_sol = solve([
+    2*x + 3*y - 7,
+    x - y + 1
+], [x, y])  # {x: 4/5, y: 9/5}
+
+# Differential equations
+from sympy import Function, dsolve, Derivative
+f = Function("f")
+
+# f''(x) + f(x) = 0  (simple harmonic oscillator)
+ode = Eq(f(x).diff(x, 2) + f(x), 0)
+general_solution = dsolve(ode, f(x))
+# f(x) = C1*sin(x) + C2*cos(x)
+
+# With initial conditions
+particular = dsolve(ode, f(x), ics={f(0): 1, f(x).diff(x).subs(x, 0): 0})
+# f(x) = cos(x)
+```
+
+## Linear Algebra
+
+### Symbolic Matrix Operations
+
+```python
+from sympy import Matrix, eye, zeros, det, Rational
+
+# Define a symbolic matrix
+A = Matrix([
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 10]
+])
+
+# Basic operations
+print(f"Determinant: {det(A)}")           # -3
+print(f"Inverse:\n{A.inv()}")
+print(f"Eigenvalues: {A.eigenvals()}")
+print(f"Rank: {A.rank()}")
+
+# Characteristic polynomial
+lam = symbols("lambda")
+char_poly = (A - lam * eye(3)).det()
+char_poly = expand(char_poly)
+
+# Jordan normal form
+P, J = A.jordan_form()
+
+# Null space and column space
+null = A.nullspace()
+col_space = A.columnspace()
+
+# Symbolic matrix with parameters
+M = Matrix([
+    [a, b],
+    [c, a]
+])
+eigenvals = M.eigenvals()  # {a - sqrt(b*c): 1, a + sqrt(b*c): 1}
+```
+
+## SageMath for Research
+
+### Number Theory
+
+```python
+# SageMath syntax (Python-based, but with enhanced number theory)
+# Run in SageMath environment or via sage -python
+
+"""
+# Prime factorization
+factor(2024)  # 2^3 * 11 * 23
+
+# Modular arithmetic
+R = IntegerModRing(17)
+R(3)^(-1)  # multiplicative inverse of 3 mod 17
+
+# Elliptic curves
+E = EllipticCurve(QQ, [-1, 0])
+E.rank()
+E.torsion_subgroup()
+E.gens()
+
+# Polynomial rings
+R.<x,y> = PolynomialRing(QQ)
+I = R.ideal(x^2 + y^2 - 1, x - y)
+I.groebner_basis()  # [y^2 - 1/2, x - y]
+
+# Group theory
+G = SymmetricGroup(4)
+G.order()           # 24
+G.center()
+G.normal_subgroups()
+"""
+```
+
+### Combinatorics and Graph Theory
+
+```python
+"""
+# SageMath combinatorics
+Partitions(10).cardinality()  # 42
+
+# Graph theory
+G = graphs.PetersenGraph()
+G.chromatic_number()      # 3
+G.is_vertex_transitive()  # True
+G.automorphism_group().order()  # 120
+
+# Posets and lattices
+P = posets.BooleanLattice(3)
+P.is_lattice()
+P.mobius_function(P.bottom(), P.top())
+"""
+```
+
+## Mathematica / Wolfram Language
+
+### Common Research Patterns
+
+```mathematica
+(* Symbolic integration *)
+Integrate[x^n * Exp[-x], {x, 0, Infinity}, Assumptions -> n > -1]
+(* Result: Gamma[1 + n] *)
+
+(* Solve a PDE *)
+DSolve[D[u[x, t], t] == k * D[u[x, t], {x, 2}], u[x, t], {x, t}]
+
+(* Asymptotic expansion *)
+Series[Gamma[n + 1], {n, Infinity, 3}]
+
+(* Minimize with constraints *)
+NMinimize[{x^2 + y^2, x + y >= 1}, {x, y}]
+
+(* Compute a sum in closed form *)
+Sum[1/k^2, {k, 1, Infinity}]  (* Pi^2/6 *)
+```
+
+## Practical Workflows
+
+### Verifying Research Computations
+
+Common CAS workflow in mathematical research:
+
+1. **Conjecture formulation**: Test conjectures for small cases programmatically
+2. **Identity verification**: Verify algebraic identities symbolically
+3. **Closed-form discovery**: Use pattern matching and OEIS lookup
+4. **Proof assistance**: Compute bounds, verify inequalities
+5. **Counterexample search**: Systematically search parameter spaces
+
+```python
+from sympy import simplify, Abs
+
+def verify_identity(lhs, rhs):
+    """Verify a proposed mathematical identity symbolically."""
+    diff = simplify(lhs - rhs)
+    if diff == 0:
+        return "VERIFIED: identity holds symbolically"
+    else:
+        return f"NOT VERIFIED: difference = {diff}"
+
+# Example: verify Cauchy-Schwarz for 2D
+a1, a2, b1, b2 = symbols("a1 a2 b1 b2", real=True)
+lhs = (a1*b1 + a2*b2)**2
+rhs = (a1**2 + a2**2) * (b1**2 + b2**2)
+diff = expand(rhs - lhs)
+# (a1*b2 - a2*b1)**2 >= 0, confirming Cauchy-Schwarz
+```
+
+## Tools and Resources
+
+- **SymPy**: Pure Python CAS, integrates with Jupyter and NumPy
+- **SageMath**: Comprehensive open-source math system (wraps GAP, PARI, Singular, etc.)
+- **Mathematica / Wolfram Alpha**: Commercial CAS with unmatched integration database
+- **Maxima**: Free CAS (Lisp-based), used in wxMaxima GUI
+- **PARI/GP**: Specialized in number theory computations
+- **Macaulay2**: Commutative algebra and algebraic geometry
+- **GAP**: Computational group theory
+- **OEIS (oeis.org)**: Online Encyclopedia of Integer Sequences for pattern identification

package/skills/domains/math/topology-data-analysis/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: topology-data-analysis
+description: "Topological data analysis: persistent homology, Mapper, and TDA tools"
+metadata:
+  openclaw:
+    emoji: "linked-paperclips"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["topology", "persistent-homology", "tda", "mapper", "betti-numbers", "point-cloud"]
+    source: "wentor"
+---
+
+# Topological Data Analysis
+
+A skill for applying topological data analysis (TDA) methods to research data. Covers persistent homology, Vietoris-Rips complexes, persistence diagrams, the Mapper algorithm, and vectorization methods for integrating topological features into machine learning pipelines.
+
+## Core Concepts
+
+### Simplicial Complexes from Data
+
+TDA extracts topological features (connected components, loops, voids) from data by building simplicial complexes at multiple scales:
+
+| Complex | Construction | Computational Cost |
+|---------|-------------|-------------------|
+| Vietoris-Rips | Edge if distance < epsilon | O(n^d) for d-simplices |
+| Cech | Ball intersection (exact) | Computationally expensive |
+| Alpha | Delaunay-based (exact in low dim) | Efficient in R^2, R^3 |
+| Cubical | Grid-based (for images) | Linear in pixels |
+
+### Filtration and Persistence
+
+```
+Scale epsilon:  0.1    0.3    0.5    0.7    1.0
+                |------|------|------|------|------|
+Components:      10      6      3      2      1
+  (H0 features born at 0, die at merging scale)
+
+Loops:           0      0      1      2      0
+  (H1 features born when loop forms, die when filled)
+```
+
+A feature that persists across many scales is a genuine topological signal; short-lived features are noise.
+
+## Persistent Homology with Ripser
+
+### Computing Persistence Diagrams
+
+```python
+import numpy as np
+from ripser import ripser
+from persim import plot_diagrams
+
+def compute_persistence(point_cloud: np.ndarray,
+                         max_dim: int = 2,
+                         max_edge: float = 2.0) -> dict:
+    """
+    Compute persistent homology of a point cloud.
+    point_cloud: (n_points, n_dimensions) array
+    max_dim: maximum homology dimension to compute
+    max_edge: maximum edge length in Rips complex
+    Returns persistence diagrams for each dimension.
+    """
+    result = ripser(
+        point_cloud,
+        maxdim=max_dim,
+        thresh=max_edge,
+    )
+
+    diagrams = result["dgms"]
+    summary = {}
+
+    for dim, dgm in enumerate(diagrams):
+        # Filter out infinite death times for H0
+        finite = dgm[dgm[:, 1] < np.inf] if len(dgm) > 0 else dgm
+        lifetimes = finite[:, 1] - finite[:, 0] if len(finite) > 0 else np.array([])
+
+        summary[f"H{dim}"] = {
+            "n_features": len(finite),
+            "max_persistence": float(lifetimes.max()) if len(lifetimes) > 0 else 0,
+            "mean_persistence": float(lifetimes.mean()) if len(lifetimes) > 0 else 0,
+            "birth_death_pairs": finite.tolist(),
+        }
+
+    return summary
+
+# Example: torus point cloud
+def sample_torus(n=1000, R=3.0, r=1.0, noise=0.1):
+    """Sample points from a torus in R^3."""
+    theta = np.random.uniform(0, 2 * np.pi, n)
+    phi = np.random.uniform(0, 2 * np.pi, n)
+    x = (R + r * np.cos(phi)) * np.cos(theta) + np.random.normal(0, noise, n)
+    y = (R + r * np.cos(phi)) * np.sin(theta) + np.random.normal(0, noise, n)
+    z = r * np.sin(phi) + np.random.normal(0, noise, n)
+    return np.column_stack([x, y, z])
+
+torus = sample_torus(500)
+persistence = compute_persistence(torus, max_dim=2)
+# Expected: H0 has 1 long-lived component,
+#           H1 has 2 prominent loops (the two fundamental cycles),
+#           H2 has 1 prominent void (the cavity)
+```
+
+## Persistence Vectorization
+
+### Converting Persistence to Feature Vectors
+
+To use topological features in machine learning, persistence diagrams must be vectorized:
+
+```python
+from sklearn.base import BaseEstimator, TransformerMixin
+
+class PersistenceStatistics(BaseEstimator, TransformerMixin):
+    """
+    Extract statistical features from persistence diagrams.
+    Produces a fixed-length feature vector from variable-length diagrams.
+    """
+
+    def __init__(self, max_dim: int = 1):
+        self.max_dim = max_dim
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, diagrams_list: list) -> np.ndarray:
+        features = []
+        for diagrams in diagrams_list:
+            row = []
+            for dim in range(self.max_dim + 1):
+                dgm = diagrams[dim]
+                lifetimes = dgm[:, 1] - dgm[:, 0]
+                lifetimes = lifetimes[np.isfinite(lifetimes)]
+
+                if len(lifetimes) == 0:
+                    row.extend([0, 0, 0, 0, 0, 0])
+                else:
+                    row.extend([
+                        len(lifetimes),              # count
+                        np.sum(lifetimes),            # total persistence
+                        np.max(lifetimes),            # max persistence
+                        np.mean(lifetimes),           # mean persistence
+                        np.std(lifetimes),            # std persistence
+                        np.sum(lifetimes ** 2),       # persistence entropy proxy
+                    ])
+            features.append(row)
+        return np.array(features)
+```
+
+### Persistence Images
+
+```python
+def persistence_image(diagram: np.ndarray, resolution: int = 20,
+                       sigma: float = 0.1,
+                       weight_fn=None) -> np.ndarray:
+    """
+    Compute a persistence image from a persistence diagram.
+    Transforms birth-death pairs into a stable, fixed-size representation.
+    """
+    if weight_fn is None:
+        weight_fn = lambda birth, persistence: persistence
+
+    # Transform to birth-persistence coordinates
+    births = diagram[:, 0]
+    persistences = diagram[:, 1] - diagram[:, 0]
+
+    # Create grid
+    x_range = np.linspace(births.min() - sigma, births.max() + sigma, resolution)
+    y_range = np.linspace(0, persistences.max() + sigma, resolution)
+    xx, yy = np.meshgrid(x_range, y_range)
+
+    image = np.zeros((resolution, resolution))
+
+    for b, p in zip(births, persistences):
+        if not np.isfinite(p):
+            continue
+        w = weight_fn(b, p)
+        gaussian = w * np.exp(-((xx - b)**2 + (yy - p)**2) / (2 * sigma**2))
+        image += gaussian
+
+    return image
+```
+
+## The Mapper Algorithm
+
+### Constructing Mapper Graphs
+
+Mapper provides a compressed topological summary of high-dimensional data:
+
+```python
+import kmapper as km
+from sklearn.cluster import DBSCAN
+
+def run_mapper(data: np.ndarray, lens_fn=None, n_cubes: int = 10,
+               overlap: float = 0.3) -> dict:
+    """
+    Run the Mapper algorithm to produce a simplicial complex
+    summarizing the shape of the data.
+    data: (n_samples, n_features) array
+    lens_fn: filter function (default: first two PCA components)
+    """
+    mapper = km.KeplerMapper(verbose=0)
+
+    # Compute lens (filter function)
+    if lens_fn is None:
+        from sklearn.decomposition import PCA
+        lens = mapper.fit_transform(data, projection=PCA(n_components=2))
+    else:
+        lens = lens_fn(data)
+
+    # Build the Mapper graph
+    graph = mapper.map(
+        lens, data,
+        cover=km.Cover(n_cubes=n_cubes, perc_overlap=overlap),
+        clusterer=DBSCAN(eps=0.5, min_samples=3),
+    )
+
+    # Summary statistics
+    n_nodes = len(graph["nodes"])
+    n_edges = sum(len(v) for v in graph["links"].values()) // 2
+
+    return {
+        "n_nodes": n_nodes,
+        "n_edges": n_edges,
+        "node_sizes": [len(v) for v in graph["nodes"].values()],
+        "graph": graph,
+    }
+```
+
+### Mapper Parameters
+
+| Parameter | Effect | Guidance |
+|-----------|--------|---------|
+| Filter function | Projects data to low dimensions | PCA, eccentricity, density |
+| Number of intervals | Controls resolution of cover | 10-30 typical |
+| Overlap percentage | Controls connectivity | 20-50%, higher = more edges |
+| Clustering algorithm | Groups points within intervals | DBSCAN, single-linkage |
+
+## Stability and Statistical Significance
+
+### Bottleneck and Wasserstein Distances
+
+```python
+from persim import bottleneck, wasserstein
+
+def compare_persistence_diagrams(dgm1: np.ndarray,
+                                   dgm2: np.ndarray) -> dict:
+    """
+    Compare two persistence diagrams using standard TDA distances.
+    """
+    bn_dist = bottleneck(dgm1, dgm2)
+    ws_dist = wasserstein(dgm1, dgm2, order=2)
+
+    return {
+        "bottleneck_distance": round(bn_dist, 6),
+        "wasserstein_2_distance": round(ws_dist, 6),
+    }
+```
+
+### Permutation Test for Topological Features
+
+```python
+def permutation_test_persistence(data1: np.ndarray, data2: np.ndarray,
+                                   n_permutations: int = 1000,
+                                   dim: int = 1) -> dict:
+    """
+    Test whether two point clouds have significantly different
+    topological features using a permutation test on Wasserstein distance.
+    """
+    from persim import wasserstein
+
+    # Observed distance
+    dgm1 = ripser(data1, maxdim=dim)["dgms"][dim]
+    dgm2 = ripser(data2, maxdim=dim)["dgms"][dim]
+    observed = wasserstein(dgm1, dgm2)
+
+    # Permutation distribution
+    combined = np.vstack([data1, data2])
+    n1 = len(data1)
+    perm_distances = []
+
+    for _ in range(n_permutations):
+        perm = np.random.permutation(len(combined))
+        perm_d1 = combined[perm[:n1]]
+        perm_d2 = combined[perm[n1:]]
+        perm_dgm1 = ripser(perm_d1, maxdim=dim)["dgms"][dim]
+        perm_dgm2 = ripser(perm_d2, maxdim=dim)["dgms"][dim]
+        perm_distances.append(wasserstein(perm_dgm1, perm_dgm2))
+
+    p_value = np.mean(np.array(perm_distances) >= observed)
+
+    return {
+        "observed_distance": round(observed, 6),
+        "p_value": round(p_value, 4),
+        "significant_at_005": p_value < 0.05,
+    }
+```
+
+## Tools and Libraries
+
+- **Ripser / ripser.py**: Fast Vietoris-Rips persistence computation
+- **GUDHI**: Comprehensive TDA library (C++ with Python bindings)
+- **persim**: Persistence diagram distances and visualization
+- **KeplerMapper**: Python Mapper algorithm implementation
+- **giotto-tda**: TDA integrated with scikit-learn API
+- **Dionysus 2**: Persistent homology and cohomology
+- **scikit-tda**: Meta-package bundling ripser, persim, kepler-mapper, tadasets