Ramanujan Machine Team Member

• Numerical verification is non-negotiable. Every formula, identity, or transformation must be checked by writing code and running it. Compute the formula numerically and verify it converges to the expected constant to high precision. Never trust a symbolic result without numerical confirmation.
• ALWAYS validate benchmarks: naive sequential vs proposed solution, exact fraction match + digit accuracy against known constants.
• Continually expand this skills directory to capture newly learned optimizations and mathematical principles.
• When adding new matrix generators (new constants / PCFs), always include: the matrix definition, expected digit growth rate, and a reference high-precision constant value.
• Performance matters. Always measure wall-clock time of computations. Write C extensions when Python is too slow for inner loops. Profile before optimizing — identify the actual bottleneck.

Guardrails: Verify Everything Numerically

The most dangerous failure mode is producing a formula that looks correct symbolically but is numerically wrong. To prevent this:

1. Write a test script for every new formula or transformation. Compute the first 50–200 terms and check convergence to the expected constant.
2. Use mpmath with sufficient precision (at least 100 decimal places). Never rely on 15-digit float accuracy for verification — limited decimal precision causes false matches and missed errors.
3. Cross-validate against known reference values. Use mpmath.mp.dps = 500 or higher when checking newly discovered formulas.
4. Test edge cases: $n=0$, $n=1$, and negative indices if applicable.
5. If a formula diverges or converges to the wrong value, it is wrong. Do not rationalize numerical discrepancies — debug them.

Symbolic Computation Tools

Use the best tool for each symbolic task:

• SymPy: Default for symbolic algebra, polynomial manipulation, series expansion, recurrence solving. Use sympy.simplify, sympy.cancel, sympy.factor liberally.
• mpmath: Arbitrary-precision numerical computation. Always available via from mpmath import mp, mpf, nstr. Set mp.dps high enough for the task.
• ramanujantools (pip install ramanujantools): The group's own symbolic/numeric library for CMFs, PCFs, linear recurrences. Use this as the primary tool for Ramanujan Machine work.
• Mathematica / Wolfram Language: For heavy symbolic computation, hypergeometric simplification, and RISC package integration. Use when SymPy is insufficient.
• RISC packages (Research Institute for Symbolic Computation, JKU Linz): Specialized tools for combinatorics, special functions, and guessing recurrences. The Guess package converts sequences to recurrences. Access may require a Mathematica license — ask the team for access.
• Tell the team when external tools would help. Special access to commercial/academic tools is available.

High-Precision Arithmetic: Avoiding Pitfalls

• Never use Python float for mathematical verification. Always use mpmath.mpf or sympy.Rational.
• p-adic arithmetic can be useful for detecting algebraic relations and for modular approaches to integer sequences.
• Big integer manipulation: Use Python's native arbitrary-precision integers. For performance-critical paths, use GMP via gmpy2.
• Rational reconstruction: When recovering $p/q$ from modular residues, use the Extended Euclidean Algorithm with bounds $\sqrt{M/2}$.
• Guard against precision loss: When subtracting nearly-equal large numbers, increase working precision by a safety factor of 2×–3×.

Project-Specific Context: fast_matrix_mult

What This Subproject Does

Evaluates holonomic matrix products $M(N) \cdot M(N-1) \cdots M(1)$ to extract exact rational convergents of mathematical constants ($e$, $\zeta(3)$, $\pi$, etc.).

Key Files