@wentorai/research-plugins 1.0.0

package/skills/domains/math/linear-algebra-applications/SKILL.md

@@ -0,0 +1,227 @@
+---
+name: linear-algebra-applications
+description: "Apply linear algebra concepts to research computing and data analysis"
+metadata:
+  openclaw:
+    emoji: "1234"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["linear algebra", "matrix decomposition", "SVD", "eigenvalues", "PCA", "numerical computing"]
+    source: "wentor-research-plugins"
+---
+
+# Applied Linear Algebra for Research
+
+A skill for applying linear algebra to research computing, data analysis, and scientific modeling. Covers matrix decompositions, eigenvalue problems, least squares, dimensionality reduction, and practical implementation in NumPy/SciPy.
+
+## Essential Operations
+
+### Matrix Multiplication and Solving Systems
+
+```python
+import numpy as np
+from scipy import linalg
+
+
+def solve_linear_system(A: np.ndarray, b: np.ndarray) -> dict:
+    """
+    Solve Ax = b and analyze the system.
+
+    Args:
+        A: Coefficient matrix (n x n)
+        b: Right-hand side vector (n,)
+    """
+    n = A.shape[0]
+
+    # Check condition number (sensitivity to perturbations)
+    cond = np.linalg.cond(A)
+
+    result = {
+        "shape": A.shape,
+        "rank": np.linalg.matrix_rank(A),
+        "condition_number": cond,
+        "well_conditioned": cond < 1e10,
+    }
+
+    if result["rank"] == n:
+        x = np.linalg.solve(A, b)
+        result["solution"] = x
+        result["residual_norm"] = np.linalg.norm(A @ x - b)
+    else:
+        # Underdetermined or singular -- use least-squares
+        x, residuals, rank, sv = np.linalg.lstsq(A, b, rcond=None)
+        result["least_squares_solution"] = x
+        result["note"] = "System is rank-deficient; least-squares solution returned"
+
+    return result
+```
+
+## Matrix Decompositions
+
+### LU Decomposition (Solving Multiple Systems)
+
+```python
+def lu_factorization(A: np.ndarray) -> dict:
+    """
+    LU decomposition for efficiently solving Ax=b for multiple b.
+    """
+    P, L, U = linalg.lu(A)
+
+    return {
+        "P": P,  # Permutation matrix
+        "L": L,  # Lower triangular
+        "U": U,  # Upper triangular
+        "usage": (
+            "Once computed, solve for any new right-hand side b "
+            "in O(n^2) instead of O(n^3). Use scipy.linalg.lu_solve()."
+        )
+    }
+```
+
+### Singular Value Decomposition (SVD)
+
+```python
+def svd_analysis(A: np.ndarray) -> dict:
+    """
+    SVD of matrix A = U S V^T and its applications.
+
+    Args:
+        A: Input matrix (m x n)
+    """
+    U, s, Vt = np.linalg.svd(A, full_matrices=False)
+
+    return {
+        "U_shape": U.shape,       # Left singular vectors (m x k)
+        "singular_values": s,      # Sorted descending
+        "Vt_shape": Vt.shape,     # Right singular vectors (k x n)
+        "rank": np.sum(s > 1e-10),
+        "condition_number": s[0] / s[-1] if s[-1] > 0 else float("inf"),
+        "energy_ratio": np.cumsum(s ** 2) / np.sum(s ** 2),
+        "applications": [
+            "Low-rank approximation (truncated SVD)",
+            "Principal Component Analysis (PCA)",
+            "Pseudoinverse computation",
+            "Latent Semantic Analysis (LSA) in text mining",
+            "Image compression",
+            "Noise reduction"
+        ]
+    }
+```
+
+### Eigendecomposition
+
+```python
+def eigen_analysis(A: np.ndarray) -> dict:
+    """
+    Eigenvalue decomposition of a square matrix.
+    """
+    eigenvalues, eigenvectors = np.linalg.eig(A)
+
+    # Sort by magnitude
+    idx = np.argsort(np.abs(eigenvalues))[::-1]
+
+    return {
+        "eigenvalues": eigenvalues[idx],
+        "eigenvectors": eigenvectors[:, idx],
+        "is_symmetric": np.allclose(A, A.T),
+        "is_positive_definite": (
+            np.all(np.real(eigenvalues) > 0)
+            if np.allclose(A, A.T) else "N/A (not symmetric)"
+        ),
+        "spectral_radius": np.max(np.abs(eigenvalues)),
+        "trace_check": (
+            f"Sum of eigenvalues: {np.sum(eigenvalues):.4f}, "
+            f"Trace of A: {np.trace(A):.4f}"
+        )
+    }
+```
+
+## Research Applications
+
+### Principal Component Analysis
+
+```python
+def pca_from_scratch(X: np.ndarray, n_components: int = 2) -> dict:
+    """
+    PCA using eigendecomposition of the covariance matrix.
+
+    Args:
+        X: Data matrix (n_samples x n_features), centered
+        n_components: Number of principal components to retain
+    """
+    # Center the data
+    X_centered = X - X.mean(axis=0)
+
+    # Covariance matrix
+    C = np.cov(X_centered, rowvar=False)
+
+    # Eigendecomposition (symmetric matrix -> use eigh for stability)
+    eigenvalues, eigenvectors = np.linalg.eigh(C)
+
+    # Sort descending
+    idx = np.argsort(eigenvalues)[::-1]
+    eigenvalues = eigenvalues[idx]
+    eigenvectors = eigenvectors[:, idx]
+
+    # Select top components
+    components = eigenvectors[:, :n_components]
+    explained_variance = eigenvalues[:n_components]
+    total_variance = eigenvalues.sum()
+
+    # Project data
+    X_projected = X_centered @ components
+
+    return {
+        "components": components,
+        "explained_variance_ratio": explained_variance / total_variance,
+        "cumulative_variance": np.cumsum(explained_variance) / total_variance,
+        "projected_data": X_projected
+    }
+```
+
+### Least Squares Regression
+
+```python
+def least_squares_fit(X: np.ndarray, y: np.ndarray) -> dict:
+    """
+    Solve the normal equations: beta = (X^T X)^{-1} X^T y
+    """
+    # Using the numerically stable QR decomposition
+    Q, R = np.linalg.qr(X)
+    beta = linalg.solve_triangular(R, Q.T @ y)
+
+    y_hat = X @ beta
+    residuals = y - y_hat
+
+    return {
+        "coefficients": beta,
+        "r_squared": 1 - np.sum(residuals ** 2) / np.sum((y - y.mean()) ** 2),
+        "residual_norm": np.linalg.norm(residuals),
+        "method": "QR decomposition (more stable than normal equations)"
+    }
+```
+
+## Numerical Stability
+
+### Best Practices
+
+```
+1. Avoid explicitly computing matrix inverses:
+   BAD:  x = np.linalg.inv(A) @ b
+   GOOD: x = np.linalg.solve(A, b)
+
+2. Use specialized routines for structured matrices:
+   - Symmetric positive definite: Cholesky (linalg.cho_solve)
+   - Sparse: scipy.sparse.linalg.spsolve
+   - Banded: scipy.linalg.solve_banded
+
+3. Check condition numbers before solving:
+   - cond(A) > 10^10 suggests the solution may be unreliable
+   - Consider regularization (Tikhonov/ridge) for ill-conditioned systems
+
+4. Use appropriate precision:
+   - float64 for most research computing
+   - float32 for large-scale GPU computations (monitor for precision loss)
+```
+
+When working with very large matrices, leverage sparse matrix representations (scipy.sparse), iterative solvers (conjugate gradient, GMRES), and randomized algorithms (randomized SVD) to keep computation tractable.

package/skills/domains/math/numerical-methods-guide/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: numerical-methods-guide
+description: "Apply numerical methods and scientific computing techniques"
+metadata:
+  openclaw:
+    emoji: "abacus"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["numerical methods", "scientific computing", "ODE solver", "optimization", "interpolation", "finite differences"]
+    source: "wentor-research-plugins"
+---
+
+# Numerical Methods Guide
+
+A skill for applying numerical methods in scientific computing and research. Covers root finding, numerical integration, ODE solvers, optimization, interpolation, and error analysis with practical implementations in Python.
+
+## Root Finding
+
+### Newton's Method and Alternatives
+
+```python
+import numpy as np
+
+
+def newton_method(f, df, x0: float, tol: float = 1e-10,
+                  max_iter: int = 100) -> dict:
+    """
+    Newton's method for finding roots of f(x) = 0.
+
+    Args:
+        f: Function whose root we seek
+        df: Derivative of f
+        x0: Initial guess
+        tol: Convergence tolerance
+        max_iter: Maximum iterations
+    """
+    x = x0
+    history = [x]
+
+    for i in range(max_iter):
+        fx = f(x)
+        dfx = df(x)
+
+        if abs(dfx) < 1e-15:
+            return {"root": x, "converged": False,
+                    "reason": "Zero derivative encountered"}
+
+        x_new = x - fx / dfx
+        history.append(x_new)
+
+        if abs(x_new - x) < tol:
+            return {
+                "root": x_new,
+                "converged": True,
+                "iterations": i + 1,
+                "f_at_root": f(x_new),
+                "convergence": "quadratic"
+            }
+
+        x = x_new
+
+    return {"root": x, "converged": False, "reason": "Max iterations reached"}
+```
+
+### Method Selection Guide
+
+| Method | Convergence | Requires | Robustness |
+|--------|------------|----------|-----------|
+| Bisection | Linear (slow) | Bracketing interval | Very robust |
+| Newton | Quadratic (fast) | Derivative | May diverge |
+| Secant | Superlinear (~1.62) | Two initial guesses | Moderate |
+| Brent | Superlinear | Bracketing interval | Very robust |
+
+## Numerical Integration
+
+### Quadrature Methods
+
+```python
+from scipy import integrate
+
+
+def numerical_integration_comparison(f, a: float, b: float) -> dict:
+    """
+    Compare numerical integration methods.
+
+    Args:
+        f: Function to integrate
+        a: Lower bound
+        b: Upper bound
+    """
+    # Adaptive Gaussian quadrature (recommended default)
+    quad_result, quad_error = integrate.quad(f, a, b)
+
+    # Simpson's rule (fixed-point)
+    n_points = 101
+    x = np.linspace(a, b, n_points)
+    simps_result = integrate.simpson(f(x), x=x)
+
+    # Romberg integration
+    romb_result = integrate.romberg(f, a, b)
+
+    return {
+        "quad": {"value": quad_result, "error_estimate": quad_error},
+        "simpson": {"value": simps_result, "n_points": n_points},
+        "romberg": {"value": romb_result},
+        "recommendation": (
+            "Use scipy.integrate.quad for most cases. "
+            "It adaptively chooses points for accuracy."
+        )
+    }
+```
+
+## Ordinary Differential Equations
+
+### Solving Initial Value Problems
+
+```python
+from scipy.integrate import solve_ivp
+
+
+def solve_ode_system(f, t_span: tuple, y0: list,
+                     method: str = "RK45") -> dict:
+    """
+    Solve a system of ODEs: dy/dt = f(t, y).
+
+    Args:
+        f: Right-hand side function f(t, y)
+        t_span: (t_start, t_end)
+        y0: Initial conditions
+        method: Solver method (RK45, RK23, Radau, BDF, LSODA)
+    """
+    sol = solve_ivp(
+        f, t_span, y0,
+        method=method,
+        dense_output=True,
+        rtol=1e-8,
+        atol=1e-10
+    )
+
+    return {
+        "success": sol.success,
+        "message": sol.message,
+        "t": sol.t,
+        "y": sol.y,
+        "n_evaluations": sol.nfev,
+        "method_used": method
+    }
+
+
+# Example: Lorenz system (chaotic dynamics)
+def lorenz(t, state, sigma=10, rho=28, beta=8/3):
+    x, y, z = state
+    return [
+        sigma * (y - x),
+        x * (rho - z) - y,
+        x * y - beta * z
+    ]
+
+result = solve_ode_system(lorenz, (0, 50), [1.0, 1.0, 1.0])
+```
+
+### Solver Selection
+
+```
+Non-stiff problems:
+  RK45 (default):  4th/5th order Runge-Kutta, adaptive step
+  RK23:            Lower order, useful for less smooth problems
+  DOP853:          High-order, excellent for smooth problems
+
+Stiff problems:
+  Radau:           Implicit Runge-Kutta, good for stiff systems
+  BDF:             Backward differentiation formula (classic stiff solver)
+  LSODA:           Automatically switches between non-stiff and stiff
+
+How to tell if your problem is stiff:
+  - RK45 takes many tiny steps or fails to converge
+  - The system has widely separated time scales
+  - Chemical kinetics, circuit simulations often stiff
+```
+
+## Optimization
+
+### Minimization Methods
+
+```python
+from scipy.optimize import minimize
+
+
+def optimize_with_comparison(f, x0: np.ndarray,
+                              bounds: list = None) -> dict:
+    """
+    Compare optimization methods on a given objective function.
+
+    Args:
+        f: Objective function to minimize
+        x0: Initial guess
+        bounds: List of (min, max) tuples for each variable
+    """
+    results = {}
+
+    # Gradient-free
+    res_nm = minimize(f, x0, method="Nelder-Mead")
+    results["Nelder-Mead"] = {"x": res_nm.x, "fun": res_nm.fun,
+                               "nfev": res_nm.nfev}
+
+    # Gradient-based (quasi-Newton)
+    res_bfgs = minimize(f, x0, method="L-BFGS-B", bounds=bounds)
+    results["L-BFGS-B"] = {"x": res_bfgs.x, "fun": res_bfgs.fun,
+                            "nfev": res_bfgs.nfev}
+
+    return results
+```
+
+## Error Analysis
+
+### Sources of Numerical Error
+
+```
+1. Rounding error:
+   Finite precision arithmetic (float64 has ~16 significant digits)
+   Accumulates in long computations
+
+2. Truncation error:
+   Error from approximating continuous math with discrete formulas
+   Example: Finite difference df/dx ~ (f(x+h) - f(x)) / h
+
+3. Conditioning:
+   Sensitivity of the result to perturbations in input
+   Condition number quantifies this amplification
+
+Best practice: Always compare your numerical solution against
+analytical solutions (when available) or use convergence studies
+(refine the discretization and check if the answer converges).
+```
+
+When publishing numerical results, report the method used, convergence criteria, error tolerances, grid resolution (for PDEs), and validate against known test cases. Provide code so readers can reproduce your computations.

package/skills/domains/math/oeis-api/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: oeis-api
+description: "On-Line Encyclopedia of Integer Sequences API"
+metadata:
+  openclaw:
+    emoji: "🔍"
+    category: "domains"
+    subcategory: "math"
+    keywords: ["number theory", "algebra", "probability theory", "applied mathematics"]
+    source: "https://oeis.org/eishelp1.html"
+---
+
+# OEIS API Guide
+
+## Overview
+
+The On-Line Encyclopedia of Integer Sequences (OEIS) is a comprehensive database of integer sequences, founded by Neil Sloane in 1964 and now containing over 370,000 entries. It is one of the most widely cited resources in mathematics, serving as the definitive reference for identifying, cataloging, and exploring integer sequences that arise in combinatorics, number theory, algebra, analysis, and applied mathematics.
+
+The OEIS provides a web-accessible search interface that can also be used programmatically to query sequences by their terms, by A-number (the unique identifier for each sequence), or by keyword. The API returns structured data in JSON or plain text format, including the sequence terms, formulas, generating functions, references, links to related sequences, and contributed programs in various languages.
+
+Mathematicians, computer scientists, physicists, and researchers in any quantitative discipline use the OEIS to identify unknown sequences encountered in their work, verify conjectures, discover connections between different areas of mathematics, and access formulas and programs for computing sequence terms. It is an indispensable tool for both pure and applied mathematical research.
+
+## Authentication
+
+No authentication required. The OEIS is a free, open resource that does not require any API key, token, or registration. All queries are publicly accessible. The OEIS Foundation operates as a non-profit and relies on voluntary contributions.
+
+## Core Endpoints
+
+### search: Search for Sequences
+
+Search the OEIS database by sequence terms, keywords, A-number, or author name. This is the primary endpoint for querying the encyclopedia.
+
+- **URL**: `GET https://oeis.org/search`
+- **Parameters**:
+
+| Parameter | Type   | Required | Description                                                   |
+|-----------|--------|----------|---------------------------------------------------------------|
+| q         | string | Yes      | Search query: sequence terms (comma-separated), keyword, or A-number |
+| fmt       | string | No       | Output format: `json`, `text`, `html` (default)               |
+| start     | int    | No       | Offset for pagination (default 0)                             |
+
+- **Example**:
+
+```bash
+# Search by sequence terms
+curl "https://oeis.org/search?q=1,1,2,3,5,8,13,21&fmt=json"
+
+# Search by A-number
+curl "https://oeis.org/search?q=A000045&fmt=json"
+
+# Search by keyword
+curl "https://oeis.org/search?q=catalan+numbers&fmt=json"
+```
+
+- **Response**: Returns a JSON object with `count` (total results), `start`, and `results` array. Each result contains `number` (A-number as integer), `name` (description), `data` (comma-separated terms), `offset`, `formula` (array of formula strings), `comment` (array), `reference` (array of bibliographic references), `link` (array of URLs), `program` (array of code implementations), and `xref` (cross-references to related sequences).
+
+### lookup: Direct Sequence Retrieval
+
+Retrieve a specific sequence by its A-number directly via the URL path. This provides a simpler access pattern for known sequences.
+
+- **URL**: `GET https://oeis.org/A{number}`
+- **Parameters**:
+
+| Parameter | Type   | Required | Description                                             |
+|-----------|--------|----------|---------------------------------------------------------|
+| number    | int    | Yes      | The sequence A-number (in the URL path)                 |
+| fmt       | string | No       | Output format: `json`, `text`, `html`                   |
+
+- **Example**:
+
+```bash
+# Retrieve the Fibonacci sequence (A000045)
+curl "https://oeis.org/A000045?fmt=json"
+
+# Retrieve the prime numbers (A000040)
+curl "https://oeis.org/A000040?fmt=json"
+```
+
+- **Response**: Returns the same structured JSON as the search endpoint but for a single sequence, including `number`, `name`, `data`, `formula`, `maple` (Maple code), `mathematica` (Mathematica code), `program` (other language implementations), and `keyword` (classification tags like `nonn`, `easy`, `nice`).
+
+## Rate Limits
+
+No formal rate limits are published for the OEIS. However, the service is run by a non-profit organization with limited infrastructure. Users should be respectful and avoid sending more than a few requests per second. For bulk data access, the OEIS provides downloadable data files at https://oeis.org/stripped.gz (sequence terms) and https://oeis.org/names.gz (sequence names) which are more appropriate for large-scale analysis.
+
+## Common Patterns
+
+### Identify an Unknown Sequence
+
+When you encounter an integer sequence in your research and want to identify it:
+
+```python
+import requests
+
+# You found this sequence in your combinatorial analysis
+unknown_terms = "1,4,9,16,25,36,49,64"
+
+resp = requests.get("https://oeis.org/search", params={"q": unknown_terms, "fmt": "json"})
+data = resp.json()
+
+if data["count"] > 0:
+    seq = data["results"][0]
+    print(f"A{seq['number']:06d}: {seq['name']}")
+    print(f"Terms: {seq['data']}")
+    if seq.get("formula"):
+        print(f"Formula: {seq['formula'][0]}")
+else:
+    print("No matching sequence found in OEIS")
+```
+
+### Retrieve Formulas and Programs
+
+Get computational formulas and reference implementations for a known sequence:
+
+```python
+import requests
+
+# Get the Catalan numbers (A000108)
+resp = requests.get("https://oeis.org/A000108", params={"fmt": "json"})
+data = resp.json()
+seq = data["results"][0]
+
+print(f"Sequence: {seq['name']}")
+print(f"\nFirst terms: {seq['data']}")
+
+print("\nFormulas:")
+for f in seq.get("formula", [])[:5]:
+    print(f"  {f}")
+
+print("\nPrograms:")
+for p in seq.get("program", [])[:5]:
+    print(f"  {p}")
+```
+
+### Cross-Reference Related Sequences
+
+Explore mathematical connections through cross-references:
+
+```python
+import requests
+
+resp = requests.get("https://oeis.org/search", params={"q": "A000045", "fmt": "json"})
+data = resp.json()
+
+if data["results"]:
+    seq = data["results"][0]
+    print(f"Fibonacci numbers ({seq['name']})")
+    print(f"\nCross-references:")
+    for xref in seq.get("xref", [])[:10]:
+        print(f"  {xref}")
+```
+
+## References
+
+- Official help and documentation: https://oeis.org/eishelp1.html
+- OEIS homepage: https://oeis.org/
+- OEIS Wiki: https://oeis.org/wiki/Welcome
+- Downloadable data files: https://oeis.org/stripped.gz
+- OEIS Foundation: https://oeisf.org/