What makes math-review notable?

1.6K downloads. Trust evidence available

How should math-review be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

math-review

Verifies math-heavy code for algorithmic correctness and numerical stability Skill: math-review Owner: athola Summary: Verifies math-heavy code for algorithmic correctness and numerical stability Tags: latest:1.9.19 Version history: v1.9.19 | 2026-08-26T13:19:00.290Z | user Release v1.9.19 v1.9.17 | 2026-07-30T05:39:12.631Z | user Release v1.9.17 v1.9.16 | 2026-07-14T19:55:54.335Z | user Release v1.9.16 v1.9.14 | 2026-06-30T18:04:14.103Z | user Release v1.9.14 v1.9.13 | 2026-06-27T16:22:15.61

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.6k

Updated

Oct 10, 2026

Version

1.9.19

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.6K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.6K downloadsadoption · observed Oct 10, 2026
Latest release: 1.9.19release · observed Aug 26, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17emme0e2m3cpf7k2jvp3a84984b8z9:nm-pensive-math-review

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-athola-nm-pensive-math-review/snapshot"

Documentation

CLAWHUB

145,758 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: math-review
description: Verifies math-heavy code for algorithmic correctness and numerical stability
version: 1.9.8
triggers:
  - math
  - algorithms
  - numerical
  - stability
  - verification
  - scientific
  - reviewing scientific algorithms
  - ML models
  - or numerical code
metadata: {"openclaw": {"homepage": "https://github.com/athola/claude-night-market/tree/master/plugins/pensive", "emoji": "\ud83e\udd9e", "requires": {"config": ["night-market.pensive:shared", "night-market.imbue:proof-of-work"]}}}
source: claude-night-market
source_plugin: pensive
---

> **Night Market Skill** — ported from [claude-night-market/pensive](https://github.com/athola/claude-night-market/tree/master/plugins/pensive). For the full experience with agents, hooks, and commands, install the Claude Code plugin.


## Table of Contents

- [Quick Start](#quick-start)
- [When to Use](#when-to-use)
- [Required TodoWrite Items](#required-todowrite-items)
- [Core Workflow](#core-workflow)
- [1. Context Sync](#1-context-sync)
- [2. Requirements Mapping](#2-requirements-mapping)
- [3. Derivation Verification](#3-derivation-verification)
- [4. Stability Assessment](#4-stability-assessment)
- [5. Proof of Work](#5-proof-of-work)
- [Progressive Loading](#progressive-loading)
- [Essential Checklist](#essential-checklist)
- [Output Format](#output-format)
- [Summary](#summary)
- [Context](#context)
- [Requirements Analysis](#requirements-analysis)
- [Derivation Review](#derivation-review)
- [Stability Analysis](#stability-analysis)
- [Issues](#issues)
- [Recommendation](#recommendation)
- [Exit Criteria](#exit-criteria)


# Mathematical Algorithm Review

Intensive analysis ensuring numerical stability and alignment with standards.

## Quick Start

```bash
/math-review
```
**Verification:** Run the command with `--help` flag to verify availability.

## When To Use

- Changes to mathematical models or algorithms
- Statistical routines or probabilistic logic
- Numerical integration or optimization
- Scientific computing code
- ML/AI model implementations
- Safety-critical calculations

## When NOT To Use

- General algorithm review -
  use architecture-review
- Performance optimization - use parseltongue:python-performance
- General algorithm review -
  use architecture-review
- Performance optimization - use parseltongue:python-performance

## Required TodoWrite Items

1. `math-review:context-synced`
2. `math-review:requirements-mapped`
3. `math-review:derivations-verified`
4. `math-review:stability-assessed`
5. `math-review:evidence-logged`

## Core Workflow

### 1. Context Sync
```bash
pwd && git status -sb && git diff --stat origin/main..HEAD
```
**Verification:** Run `git status` to confirm working tree state.
Enumerate math-heavy files (source, tests, docs, notebooks). Classify risk: safety-critical, financial, ML fairness.

### 2. Requirements Mapping
Translate requirements → mathematical invariants. Document pre/post conditions, conservation laws, bounds. **Load

_meta.json

{
  "ownerId": "kn7d107jg9jv602h9ytsegydq184a42s",
  "slug": "nm-pensive-math-review",
  "version": "1.9.19",
  "publishedAt": 1787750340290
}

modules/derivation-verification.md

---
parent_skill: pensive:math-review
load_priority: high
estimated_tokens: 350
---

# Derivation Verification

## Re-derive Critical Formulas

**Symbolic Verification**
- Use Computer Algebra Systems (SymPy, Mathematica, Maple)
- Confirm algebraic manipulations
- Verify calculus operations (derivatives, integrals)
- Check limit behavior

**Computational Notebooks**
```python
# Example: Verify gradient computation
import sympy as sp
x, y = sp.symbols('x y')
f = x**2 + y**2
grad_f = [sp.diff(f, var) for var in [x, y]]
# Compare with implementation
```

**Probabilistic Reasoning**
- Verify conditional probability formulas
- Check Bayes rule applications
- Confirm expectation/variance calculations
- Validate distribution properties

## Challenge Approximations

**Series Truncation**
- Document truncation order (e.g., O(h³))
- Estimate truncation error
- Test convergence with different orders
- Provide error bounds across domain

**Linearizations**
- Identify linearization points
- Estimate valid domain size
- Test against full nonlinear model
- Document approximation quality

**Surrogate Models**
- Compare surrogate to ground truth
- Quantify approximation error
- Document training/validation data
- Test extrapolation behavior

**Error Bounds**
- Derive theoretical error bounds
- Verify empirically
- Document worst-case scenarios
- Test at domain boundaries

## Authoritative References

**Standards and Frameworks**
- **NASA-STD-7009**: Modeling and Simulation V&V
- **ASME V&V 20**: Verification & Validation in CFD/HT
- **ASME V&V 10**: Guide for V&V in Computational Solid Mechanics
- **SIAM**: Reproducibility checklists
- **IEEE 754**: Floating-point arithmetic
- **NIST**: Uncertainty quantification guidelines

**Academic Sources**
- Peer-reviewed papers (DOI links)
- Textbooks (edition and page numbers)
- Technical reports
- Conference proceedings

**Implementation References**
- Reference implementations (NumPy, SciPy, GSL)
- Algorithm papers (original sources)
- Numerical recipes
- Domain-specific libraries

## Document Conflicts

When implementation deviates from standards:

```markdown
### Deviation: [Brief title]
- **Standard**: NASA-STD-7009 Section 3.4.2
- **Requirement**: Monte Carlo with n≥1000 samples
- **Implementation**: n=100 samples
- **Justification**: Performance constraints
- **Risk**: Reduced confidence intervals
- **Mitigation**: Document uncertainty, flag results
- **Owner**: [name]
- **Due date**: [date]
```

## Citation Format

```markdown
## References

[1] Wilkinson, J.H. (1963). *Rounding Errors in Algebraic Processes*.
    Prentice-Hall. Chapter 3.

[2] NASA-STD-7009A. (2016). *Standard for Models and Simulations*.
    Section 4.2: Verification Requirements.

[3] Goldberg, D. (1991). "What Every Computer Scientist Should Know
    About Floating-Point Arithmetic". *ACM Computing Surveys*, 23(1).
    DOI: 10.1145/103162.103163
```

## Verification Checklist

- [ ] Formulas re-derived from first principles
- [ ] Symbolic veri

modules/numerical-stability.md

---
parent_skill: pensive:math-review
load_priority: high
estimated_tokens: 400
---

# Numerical Stability Analysis

## Conditioning

**Condition Numbers**
- Measure sensitivity to input perturbations
- High condition number = unstable computation
- Use scaled condition numbers when possible

**Sensitivity Analysis**
- Perturb inputs systematically
- Measure output variation
- Document acceptable tolerance ranges

## Precision Management

**Floating-Point Error Propagation**
```python
# Bad: Accumulating small values into large
total = 1e15
for x in small_values:
    total += x  # Precision lost

# Good: Kahan summation or sort first
sorted_values = sorted(small_values)
total = sum(sorted_values)  # Better precision
```

**Catastrophic Cancellation**
```python
# Bad: Subtracting similar values
result = (a + epsilon) - a  # Catastrophic cancellation

# Good: Reformulate to avoid
result = epsilon  # Direct computation
```

**Overflow/Underflow Prevention**
- Check dynamic range before operations
- Use log-space for very large/small products
- Normalize intermediate results
- Scale inputs to manageable ranges

## Scaling and Normalization

**Dynamic Range Handling**
- Pre-scale inputs to [0, 1] or [-1, 1]
- Use log-transforms for exponential data
- Document scaling factors and units

**Normalization Requirements**
- L1/L2 normalization for vectors
- Feature scaling for ML inputs
- Unit conversions for physical quantities

## Randomness Control

**Reproducibility**
- Set explicit random seeds
- Document PRNG algorithms used
- Version lock numerical libraries
- Test deterministic behavior

**Seed Management**
```python
# Good: Explicit seed control
import numpy as np
np.random.seed(42)

# Better: Isolated RNG state
rng = np.random.RandomState(42)
samples = rng.normal(0, 1, size=100)
```

## Complexity Analysis

Compare algorithmic complexity before/after changes:

```
Before: O(n²) time, O(n) space
After:  O(n log n) time, O(n) space
Improvement: 100x faster for n=1000
```

Document:
- Time complexity
- Space complexity
- Cache behavior
- Parallelization potential

## Uncertainty Quantification

Required for:
- Safety-critical systems
- Data-driven components
- High-stakes decisions
- Regulatory compliance

Methods:
- Monte Carlo sampling
- Bootstrap confidence intervals
- Sensitivity analysis
- Error propagation formulas

## Stability Checklist

- [ ] Condition number < 1e6
- [ ] Precision loss < 1e-10
- [ ] No catastrophic cancellation
- [ ] Overflow/underflow prevented
- [ ] Scaling applied appropriately
- [ ] Random seeds controlled
- [ ] Complexity acceptable
- [ ] Uncertainty quantified (if required)

modules/requirements-mapping.md

---
parent_skill: pensive:math-review
load_priority: medium
estimated_tokens: 300
---

# Requirements Mapping

## Mathematical Invariants

Translate requirements into verifiable mathematical properties:

| Requirement | Invariant | Test Coverage |
|-------------|-----------|---------------|
| Positive output | f(x) > 0 ∀ x ∈ domain | Property test |
| Conservation | Σ mass_in = Σ mass_out | Unit test |
| Bounded error | \|ε\| < 1e-6 | Benchmark |
| Monotonicity | x₁ < x₂ ⟹ f(x₁) ≤ f(x₂) | Property test |
| Idempotence | f(f(x)) = f(x) | Unit test |

## Pre-conditions

**Input Validation**
```python
def compute(x: float, n: int) -> float:
    """Compute function with documented preconditions.

    Preconditions:
    - x ≥ 0 (non-negative input)
    - n > 0 (positive integer)
    - x < 1e10 (prevent overflow)
    """
    if x < 0:
        raise ValueError("x must be non-negative")
    if n <= 0:
        raise ValueError("n must be positive")
    if x >= 1e10:
        raise ValueError("x must be < 1e10")
    # ... implementation
```

**Domain Constraints**
- Valid input ranges
- Type requirements
- Dimensional consistency
- Unit compatibility

## Post-conditions

**Output Guarantees**
```python
def normalize(vector: np.ndarray) -> np.ndarray:
    """Normalize vector to unit length.

    Postconditions:
    - ||result|| = 1.0 (± 1e-10)
    - result ∥ vector (parallel)
    """
    result = vector / np.linalg.norm(vector)
    assert abs(np.linalg.norm(result) - 1.0) < 1e-10
    return result
```

**Invariant Preservation**
- Conservation laws maintained
- Bounds respected
- Relationships preserved

## Conservation Laws

**Physical Conservation**
- Mass conservation
- Energy conservation
- Momentum conservation
- Charge conservation

**Numerical Conservation**
- Probability sums to 1.0
- Symmetry preservation
- Balance equations

## Monotonicity Guarantees

**Increasing Functions**
```python
# Property test
@given(st.floats(min_value=0, max_value=100))
def test_monotonic_increasing(x1, x2):
    assume(x1 < x2)
    assert f(x1) <= f(x2)
```

**Convexity/Concavity**
- Second derivative tests
- Jensen's inequality
- Midpoint properties

## Probabilistic Bounds

**Confidence Intervals**
- Document confidence levels (95%, 99%)
- Specify interval type (credible, confidence)
- Test coverage probabilities

**Error Probabilities**
- Type I/II error rates
- False positive/negative rates
- Statistical power

## Coverage Gap Analysis

Identify untested invariants:

```markdown
### Coverage Gaps

**Missing Tests**
- [ ] Boundary condition: x = 0
- [ ] Overflow case: x > 1e15
- [ ] Negative input handling
- [ ] Conservation at t → ∞

**Insufficient Coverage**
- [ ] Only 3 test cases for n-dimensional invariant
- [ ] No property tests for monotonicity
- [ ] Missing edge case: empty input
```

## Documentation Template

```python
def algorithm(inputs) -> outputs:
    """Brief description.

    Mathematical Properties:
    - Preconditions: [domain constraints]
    - Pos

Github ReposUpdated 15h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.