ramanujan-qft 0.3.0a4__tar.gz

ramanujan_qft-0.3.0a4/AUDIT.md

@@ -0,0 +1,207 @@
+# Pre-release audit (October 2026)
+
+This file records what was checked before making the repository public, how it
+was checked, what was found, and what was changed. Every number below can be
+reproduced with the scripts in `tests/` and `benchmarks/`.
+
+## How the code was checked
+
+* **LoopTools 2.16** (the vendored copy, built with gfortran) as the reference
+  for one-loop integrals: values in `tests/data/looptools_reference.csv`.
+* **Independent integrations** written from first principles: Feynman-parameter
+  integrals with the inner integration done analytically (mpmath), and 2-D
+  Feynman-parameter integrals for the two-loop sunset (SciPy).
+* **Several working precisions** (15, 30, 50/60 digits). A correct method must
+  give the same answer at every precision.
+* **A clean install** of the package outside the repository, in a fresh venv.
+
+## Findings in version 0.1 and their status
+
+| # | Component | Finding | Evidence | Status in 0.2 |
+|---|-----------|---------|----------|---------------|
+| 1 | Packaging | `import ramanujan_qft` failed after installation: `core/ramanujan_framework.py` imported `feynman_atlas`, a file in the repository root that is not part of the package. | `ModuleNotFoundError: feynman_atlas` in a clean environment | **Fixed.** `pyproject.toml` added; clean venv install tested |
+| 2 | `solve_B0_standard`, equal-mass `solve_C0_standard` above threshold | A hard-coded regulator `delta = 1e-30` combined with the precision setting gave correct values only for `precision >= 50`. At 30 digits B0(1;1,1) returned -0.375 instead of -0.391, and C0(0,0,5;1,1,1) was off by 0.11. At 15 digits it crashed with "gamma function pole". | `tests/test_legacy_api.py`, `tests/test_one_loop.py` | **Fixed.** Exact closed forms, correct at every precision |
+| 3 | `solve_B0_standard` convention | The finite part differs from LoopTools by exactly -γ_E (RAF -0.39102 vs LoopTools +0.18620 at p²=1). The README stated a perfect match with LoopTools. | LoopTools run | **Documented.** The legacy method keeps its convention; the new `one_loop.B0` uses LoopTools conventions |
+| 4 | Unequal-mass C0 | **Correct.** Matches LoopTools and the independent integration to working precision, including degenerate masses. | `tests/test_one_loop.py` | Kept (moved to `one_loop.C0`) |
+| 5 | `massive_sunset_residue`, Euclidean branch | Integrated `F/U^3` over the simplex. That is not the sunset finite part: it is linear in p² by construction and jumps from 466 to 1.4 across threshold. | Discontinuity test | **Withdrawn** (raises `NotImplementedError`) |
+| 6 | Sunset Im part (`phase_space_3body`) | Correct shape, but the prefactor was π/(16s) instead of π/s, and the sign was flipped. This is the "16× normalisation discovery" in `global_sunset_benchmark.py`: it is a bug, not a new effect. | Ratio is exactly 16.000000 against the Feynman-parameter Im part | **Fixed** in `sunset.sunset_im` |
+| 7 | Sunset real part (`sunset_real_dispersion`) | Fixed placeholder subtraction constants `s0 = -0.5`, `s1 = 0.1`. The dispersion integral ran straight through the pole at t = s (no principal value). | Source | **Replaced** by `sunset.sunset_subtracted`, validated to 1e-11 to 1e-14 against Feynman parameters |
+| 8 | `solve_P126` | Hard-coded log coefficients and a fixed +iπ phase, which gives a spurious imaginary part in the Euclidean region. Does not reproduce the target -1.039367 printed by the module itself (returns 0.5617+0.1401i). | Run | **Withdrawn** |
+| 9 | `solve_graph_polynomials`, `solve_elliptic_kite`, `solve_double_box_inv`, `solve_triangle3L` | The "topology parser" classifies by polynomial degree. The kite and double box were routed to the sunset with masses (1,2,3) regardless of input: changing s,t from (-3,-2) to (-30,-99) changed the "double box" only through the sunset quadrature. The 3-loop triangle and any user polynomial returned exactly 0. The "elliptic" series was an ad hoc expression. | `PolynomialStructuralParser.identify` output | **Withdrawn** |
+| 10 | `MoBDynamicEngine` | Analyses the bracket matrix, then returns `complex(0)`. | Source | **Raises** `NotImplementedError` |
+| 11 | `solve_bessel_exp_product` | Returned 0 for every input (the residue formula evaluated Γ at its poles, and a bare `except` returned 0). | `(3,4) -> 0.0` instead of 0.2 | **Fixed** via `mellin.product_integral` |
+| 12 | RACE (`solve_product`) | Correct for exp × J0 / Gaussian away from the convergence boundary. Near it, accuracy degraded silently: exp(-3x)J0(4x) gave 0.2000042 instead of 0.2. Errors were returned as strings. Poles from the large-x expansion of a factor were ignored, so factors such as 1/(x+m) gave wrong results. | Closed forms | **Rewritten:** both expansions, convergence control, pole collisions, exceptions |
+| 13 | Speed claims ("O(1)", faster than LoopTools) | LoopTools: C0 ≈ 24 µs, B0 ≈ 0.8 µs per call. RAF 0.1: C0 ≈ 22 ms, B0 up to 4.5 ms. 0.2 (precision-checked): C0 ≈ 11 ms, B0 ≈ 0.27 ms. Evaluation is not O(1) in any meaningful sense: it calls special functions and series of growing length. | `benchmarks/looptools/compare_looptools.sh` | **Claims removed** from README |
+| 14 | pySecDec "fails at the branch cut" (C0 table) | The value -0.1474950302 is not a pySecDec limitation. LoopTools and the independent integration both give -0.4219-0.3367i, and pySecDec handles this case with contour deformation. The run was most likely misconfigured (parameter order or missing contour deformation). | — | **Claim removed** |
+| 15 | Tests | The `test_*.py` files in the root contained no assertions. Some printed hard-coded "Target" values for competitors. | Source | **New suite** in `tests/`: 311 tests |
+| 16 | Benchmark scripts in the root | Require pySecDec libraries that are not in the repository (`RECREATION/`, `pysecdec_*`). Several print fixed reference numbers and labels such as "Competitor Killer". | Source | **Left untouched;** listed below for you to decide |
+
+## Originality review
+
+A literature review (references checked online or against local copies) found
+that RACE and the other methods in the package are **classical**. Credit goes
+to Hardy, Marichev and Adamchik–Marichev, Slater, Fikioris, SymPy
+`meijerint`, mpmath `meijerg`, Gonzalez–Moll–Schmidt, Prausa,
+Ananthanarayan–Banik–Friot–Ghosh and others. No copied code was found. The
+contribution is the implementation. See [docs/PRIOR_ART.md](docs/PRIOR_ART.md).
+
+## RACE (Mellin residue engine): two adversarial audits
+
+Each round used independent hunters that tried to break the engine with
+about 2,000–4,000 cases checked against closed forms (DLMF, Gradshteyn–Ryzhik,
+SymPy) and independent quadratures (contour rotation, Gauss–Legendre,
+QUADPACK). Separate agents then reproduced every claimed defect with a
+different method.
+
+**Round 1 (19 confirmed defects in the first rewrite), all fixed:**
+
+* Invalid contour closures: the asymptotic "expand the Gaussian" series
+  returned silent zeros, e.g. ∫e^(−x²)cos x dx = 0.
+* Wrong branch of the Weber–Schafheitlin discontinuous integrals.
+* Divergent integrals returned as finite numbers.
+* Uncompensated cancellation, losing 7–10 digits.
+* Near pole collisions accepted with errors up to 10¹³.
+* Tiny results accepted with only absolute accuracy.
+* Parameters frozen at 15 digits.
+* A dead `nsum` fallback.
+* A leaked private exception.
+* Quadratic-time summation.
+
+**Round 2 (28 confirmed defects after the fixes), all fixed:**
+
+*RACE:*
+
+* Inputs within 10⁻¹⁶ of a lattice point (e.g. s = 10⁻⁴⁰, ν = 10⁻²⁵) were rounded,
+  returning 0. Inputs are now represented exactly.
+* A late peak of the terms (`gaussian_bessel`) stopped the summation early. An
+  a-priori peak estimate now guards the stopping rule.
+* An over-optimistic Wynn-ε error estimate. Wynn is now used only for
+  alternating series, with disjoint-window checks.
+* Collisions near a singularity of I(s). The step δ is now scaled to the
+  distance from the singularity, with Richardson extrapolation.
+* Equal-frequency integrals with a vanishing beat term were called divergent.
+  The strip check now uses the asymptotic phases.
+* The precision cap gave up too early, with a misleading message.
+* A raw mpmath `NoConvergence` leaked out.
+* `error_estimate` ignored the final rounding.
+
+*One-loop and sunset:*
+
+* Catastrophic cancellation in B0 and C0 at extreme kinematics: B0(10⁻¹²; 1, 10⁶)
+  was 330% off. All one-loop functions are now certified by two-precision agreement.
+* C0 raised ZeroDivisionError at regular points.
+* The all-massless sunset returned an undefined quantity.
+* A quadrature node landing on t = s caused a crash.
+* The massless D=3 bubble crashed.
+
+*Helpers and tests:*
+
+* `mellin_numeric` accepted integrals divergent at x = 0.
+* A complex-z misuse of the 2F1 continuation gave the wrong branch.
+* The legacy HCF series summation was inaccurate.
+* Missing input validation.
+* Test-suite flaws: a vacuous symmetry test, a wrong reference constant, a wrong
+  closed form in a comment.
+
+Final random sweeps: every result was either correct to the requested
+accuracy or a raised `SeriesConvergenceError` / `ValueError`. **No silent wrong
+result remained.** Known, documented refusals: the convergence boundary ρ = 1
+(e.g. e^(−x) J₀(x), equal-scale products), fixed-sign series with ρ very close
+to 1, and cases needing more than `max_terms` terms. All 47 cases are
+regression tests (`tests/test_mellin_regressions.py`,
+`tests/test_round2_regressions.py`).
+
+## Round 3: one-loop and sunset
+
+A third round targeted silent wrong results only.
+
+**One-loop functions: no silent wrong result.**
+
+* 1,820 random B0 / C0 / bubble_3d / B0_mob / C0_mob cases were checked at 15, 30
+  and 50 digits, with masses from 10⁻¹² to 10¹², thresholds and pseudo-thresholds
+  included.
+* 1,740 cases at s = 0 were checked.
+* A 24,000-point comparison against LoopTools was run.
+* At the extreme hierarchies where the two disagreed, LoopTools (double precision)
+  was the one in error. The package agreed with 90-digit independent quadrature.
+
+**Defects found, all fixed:**
+
+* **`sunset_im`.** It suffered catastrophic cancellation near threshold and
+  could return 0 there. It also gave precision-independent errors at small
+  scales, because mpmath's quadrature tolerance is absolute. It now uses exact
+  homogeneity scaling, factored Källén functions with an endpoint-free
+  substitution, error-checked quadrature and a two-precision check.
+* **`sunset_subtracted` / `sunset_d2`.** These were up to 22% wrong at scales
+  around 10¹², and wrong at small scales and large |s|/th. They are now scaled
+  to the threshold, use a 1/t tail map, normalise each integrand, and are
+  certified. They are validated against a closed form for masses (0, 0, M).
+* **C0 with a massless internal line.** It was refused with a false "IR
+  divergent" message. IR-finite configurations are now supported through a
+  general imaginary part with clipped roots. Only the truly divergent cases
+  (m1 = m2 = 0 or m2 = m3 = 0) raise.
+* **C0 at s = 0.** An unchecked quadrature fooled the certification for masses
+  ≳ 2¹⁴⁰. It is replaced by the exact divided-difference closed form.
+* **Non-finite inputs.** These are now rejected with `ValueError`. Previously one
+  call ran for more than 14 minutes.
+* **Docs.** The "exact" wording for numerical sunset values, a mis-rounded
+  LoopTools example and stale test counts were corrected.
+
+**Cost.** Certified `sunset_subtracted` / `sunset_d2` take about 10 s per value
+(up to ~40 s for |s| ≫ threshold).
+
+## Round 3: RACE
+
+The first two RACE hunters were stopped by usage limits, so the round was
+completed by a smaller, bounded run: one hunter and one independent reproducer.
+
+**Defect from the interrupted hunter (fixed).** For (x+m)^(−v) with v ≫ k·m, the
+residue terms dip and then peak again near n ≈ v. The stopping rule fired in the
+dip, so wrong values were returned silently: relative errors up to 10²¹ while
+claiming 10⁻¹⁶. The a-priori peak estimate now includes the Gamma-argument
+offsets |s|, v and |ν|. The hunter's lead maps now pass:
+
+| Map | Before | After |
+|---|---|---|
+| exp × inverse_power, large v | 34 + 21 bad | 0 bad of 288 |
+| hump / inverse-power-pair scans | 18 + 2 bad | 0 bad |
+| exp × ip and ip × ip at 15/30/50 digits | 60 bad (at 50 digits) | 0 bad of 2,880 |
+
+**Bounded hunter: 785 cases.** 700 correct and 31 honest refusals. No silent
+error for large Bessel orders (up to 200), large or complex s (|Im s| up to 400),
+inverse-power pairs with large v, `gaussian_bessel` with large ν, Wynn on growing
+alternating series, `continuation=True`, exact and near collisions, or the
+legacy engines. It found two defects, both confirmed by the reproducer with
+independent closed forms, and both fixed:
+
+1. **Long decimal-string s next to a pole of I(s).** Up to 1.4% error at dps 15.
+   String inputs are now sized by their digits and the requested precision.
+2. **Strip edges frozen at construction precision.** For string ν or v, some
+   divergent integrals returned values, and one existing integral was reported
+   divergent. The strip is now computed from the raw parameters at
+   input-sized precision.
+
+Regression tests for all of these are in `tests/test_round3_regressions.py`.
+
+## Repository hygiene: cleanup completed
+
+The research-alpha cleanup removed obsolete material from the current tree:
+
+- Vendored third-party source trees, tarballs and compiled drivers. The maintained
+  `benchmarks/looptools/compare_looptools.sh` downloads LoopTools when requested.
+- Generated `HEAD_TO_HEAD/` SecDec runs, backups and executables, and the local
+  `secdec3_local` checkout.
+- Downloaded reference PDFs, personal notes, old benchmark plots, superseded
+  paper/results drafts and the exploratory Minkowski strategy note.
+- Root-level experimental scripts and old benchmark/test drivers, plus `runners/`
+  and `scratch/`. Supported examples are in `examples/`; maintained benchmarks
+  are in `benchmarks/` and regression tests are in `tests/`.
+
+The numerical package, tested legacy compatibility interfaces, independent
+reference fixtures, current audit report and reproduction tools are retained.
+Original scientific findings above remain part of the audit record, including
+historical filenames and withdrawn claims.
+
+This cleanup does not rewrite Git history: earlier commits still contain the
+removed files. A local archive was also made before removal. Copyright-holder
+metadata and any future history rewrite are separate from this cleanup.

ramanujan_qft-0.3.0a4/CHANGELOG.md

@@ -0,0 +1,170 @@
+# Changelog
+
+## Unreleased
+
+## 0.3.0a4 — research alpha
+
+- Address all six nonblocking findings in the supplementary review of 0.3.0a2;
+  retain the original report and its scope with the release evidence.
+- Make audit and benchmark reports work from source archives without Git,
+  using source SHA-256 hashes as the binding provenance identifiers.
+- Replace ambiguous numerical “certified” claims with precision checks and
+  explain the dimension-independent zero in the sunset Gamma families.
+- Publish measured default-budget coverage at 10, 20 and 30 digits, with
+  accurate values and typed budget refusals reported separately.
+- Validate product benchmarks against a separate Gaussian Fourier/angular
+  representation, then regenerate the accuracy-checked measurements.
+- Credit Reetamshu consistently in package and citation metadata.
+- Numerical algorithms and documented domains are unchanged from 0.3.0a2.
+
+## 0.3.0a3 — replacement TestPyPI release
+
+- Restore TestPyPI availability after the earlier releases were accidentally
+  deleted. A new version is required because deleted filenames cannot be reused.
+- Use `publish.yml` and the protected `pypi` environment for TestPyPI uploads,
+  matching the replacement trusted publisher. Manual uploads target only
+  TestPyPI and require full validation and an installation check.
+- Authentication diagnostics now select PyPI or TestPyPI explicitly and report
+  allowlisted rejection codes without exposing credentials.
+- Numerical algorithms are unchanged from 0.3.0a2. Review and production PyPI publication were pending at preparation time.
+
+## 0.3.0a2 — historical TestPyPI rehearsal (files subsequently deleted)
+
+- Fixed browser startup by loading Pyodide's compiled NumPy before importing
+  the package, including custom dependency-wheel configurations.
+- Added browser examples for graph-derived sunset RMT and equal-mass Taylor
+  evaluation, and real Chromium checks for examples, references and reset.
+- Added a reproducible 30-digit comparison with three mpmath quadrature
+  methods, raw timings, source hashes and explicit accuracy failures.
+  Historical one-loop timings are labelled separately; unsupported broad
+  rankings were removed.
+- Added production publisher authentication preflight without upload, plus
+  an installation check outside the checkout after production publication.
+- Refreshed candidate metadata and the independent-parameter audit. External
+  scientific review remains pending; automated validation is not peer review.
+
+## 0.3.0a1 — TestPyPI rehearsal (not published to production PyPI)
+
+### Equal-mass continuation and release preparation
+- Added a separate D=2 equal-mass transformed Taylor series for vacuum and
+  finite Euclidean momentum, with an analytic tail bound and precision control
+  for the unstable coefficient recurrence. RMT calls retain their own domains.
+- Added a reproducible independent-parameter audit, capability table, scientific
+  review packet, research notebook and contribution instructions.
+- Publication now depends on tests, numerical audit, docs/notebook checks and
+  installed wheel/sdist checks across Linux, Windows and macOS. Added a manual
+  TestPyPI rehearsal. Hosted candidate checks passed; external review and
+  publication remain pending.
+
+### Repository cleanup
+- Removed obsolete root scripts, superseded plots/results drafts, generated
+  SecDec runs, vendored tools, binaries and downloaded PDFs from the current tree.
+- Retained the supported package and compatibility APIs, current examples,
+  maintained benchmarks, independent fixtures and reproducible audit report.
+- Updated ignore rules and packaging so generated output stays outside version
+  control and the source distribution contains the maintained reproduction files.
+- Git history is preserved; this cleanup is not a history rewrite.
+
+### Multivariate Ramanujan sunset series
+- Added exact Schwinger bracket matrices and basis solving with inspectable
+  Gamma-function summands; nonsingularity makes no convergence claim.
+- Added `compile_sunset_rmt` and `integrate_graph_rmt` for the massive,
+  unit-power two-loop sunset in D=2. The momentum-dominant and mass-dominant
+  Euclidean charts have explicit sufficient convergence domains.
+- Resolved coalescing poles analytically into logarithms and harmonic numbers.
+  Evaluation uses arbitrary-precision series summation, an analytic tail bound,
+  precision checks and bounded work, with no numerical integration fallback.
+- Added independent 40/55-digit simplex references, regulated Gamma-family
+  checks, boundary/budget tests, and comparisons with the hybrid graph backend.
+  Equal-mass vacuum and the gap between charts remain explicitly unsupported.
+
+### Multiloop graphs
+- Added immutable `ScalarEdge` and `ScalarGraph` objects with exact Symanzik
+  polynomials, conserved Euclidean external vectors, graph-derived loop counts,
+  and UV power counting over all cyclic edge subsets.
+- Added experimental `integrate_graph`: RMT integration of the Schwinger scale,
+  factored Hepp sectors with smooth boundary maps, and replicated scrambled
+  Sobol integration. Supports convergent massive scalar graphs and positive
+  fractional powers/dimension, subject to explicit work budgets.
+- Added `MultiloopResult` statistical diagnostics and strict convergence failure
+  via `MultiloopConvergenceError`; SciPy is an optional `multiloop` extra.
+- Added independent one- through four-loop checks, a graph example, and a guide
+  documenting Euclidean normalization and the remaining path to general
+  multivariate RMT, regulator expansions, and physical-region coverage.
+
+### Documentation
+- Documentation website (Sphinx, pydata-sphinx-theme), deployed to GitHub Pages by
+  `.github/workflows/docs.yml`: landing page, installation, quickstart, user guide
+  (Master Theorem, product integrals, one-loop, sunset, precision, conventions),
+  API reference, example gallery, validation, comparison, prior art, citing.
+- "Try it in your browser": an in-browser console (Pyodide in a Web Worker) that
+  runs the package without installation; a Colab quickstart notebook
+  (`notebooks/quickstart.ipynb`).
+- NumPy-style docstrings with examples for every public function; the examples run
+  as doctests in CI, and `tools/check_doc_snippets.py` runs the examples on the
+  documentation pages.
+- `CITATION.cff`; `publish.yml` for PyPI trusted publishing on a GitHub release.
+- LICENSE: the copyright line reads "In memory of Ramanujan".
+
+## 0.2.0
+
+### Added
+- `ramanujan_qft.rmt`: `ramanujan_master_theorem`, `mellin_numeric`, `massive_propagator_rmt`.
+- `ramanujan_qft.mellin`: `product_integral` with both residue expansions, the
+  large-x poles of each factor, convergence control (`SeriesConvergenceError`)
+  and pole collisions (logarithmic results). Atlas: exponential, gaussian,
+  bessel_j, cosine, sine, inverse_power, gaussian_bessel.
+- `ramanujan_qft.one_loop`: `B0` (all masses), `B0_mob`, `C0`, `C0_mob`, `bubble_3d`
+  in LoopTools conventions, certified to the requested digits (evaluation at two
+  working precisions, raised until they agree).
+- `ramanujan_qft.sunset`: `sunset_im`, `sunset_subtracted`, `sunset_d2`.
+- Test suite (311 tests) with LoopTools 2.16 reference values, independent
+  integrations and regression tests from two adversarial audits; GitHub Actions workflow; `pyproject.toml`; examples; benchmarks.
+
+### Fixed
+- The package can now be imported after installation (it no longer depends on
+  `feynman_atlas.py` in the repository root).
+- `solve_B0_standard` / `solve_C0_standard` are correct at every precision
+  (previously correct only for `precision >= 50`, and crashing at 15).
+- Sunset imaginary part: prefactor π/s instead of π/(16s), and the correct sign.
+- `solve_bessel_exp_product` returned 0.
+- `DispersionMoBEngine.reconstruct_complex`: principal value above threshold.
+- `HypergeometricConvergenceFilter.check_convergence`: a divergent series with
+  p − q − 1 = 0 was labelled "conditional".
+- Constructors no longer change the global `mpmath.mp.dps`.
+
+- RACE (`product_integral`), after two adversarial audits (47 confirmed defects,
+  all regression-tested):
+  - a-priori validity check of the contour closure (Gamma orders and scale ratio);
+  - existence check of the integral, with asymptotic phases for equal frequencies;
+  - exact representation of inputs near lattice points;
+  - a stopping rule guarded by the terms' a-priori peak;
+  - cancellation-compensated precision;
+  - Wynn epsilon only for alternating series;
+  - Richardson-extrapolated pole collisions;
+  - honest `error_estimate`.
+- B0/C0 cancellation at extreme kinematics (certification), C0 ZeroDivisionError at
+  regular points, massless D=3 bubble, sunset edge cases, `mellin_numeric` checks.
+- Round 3:
+  - sunset functions rewritten (scaling, factored Kallen functions, normalised
+    and error-checked quadrature, certification); accurate at threshold and for
+    scales 1e-12..1e12;
+  - C0 with IR-finite massless internal lines;
+  - exact C0 at s = 0;
+  - non-finite inputs rejected;
+  - RACE: Gamma-argument offsets in the peak estimate (second peak for large v),
+    exact sizing of decimal-string inputs, strip edges from raw parameters.
+
+### Withdrawn (raise `NotImplementedError`; see AUDIT.md)
+- `FeynmanMoBSolver.massive_sunset_residue`, `solve_massive_sunset`,
+  `solve_graph_polynomials`, `solve_P126`, `solve_triangle3L`,
+  `solve_elliptic_kite`, `solve_double_box_inv`.
+- `RamanujanContinuationEngine.sunset_real_dispersion`, `evaluate_minkowski_residues`.
+- `HypergeometricConvergenceFilter.compute_p126_*`.
+- `MoBDynamicEngine.stage_D_dynamic_evaluation` (it returned 0).
+
+### Changed
+- Default `precision` of the legacy classes is now 30 (was 100). Results no
+  longer depend on it.
+- RACE methods raise exceptions instead of returning error strings.
+- `matplotlib`, `scipy` and `pySecDec` are no longer runtime dependencies.

ramanujan_qft-0.3.0a4/CITATION.cff

@@ -0,0 +1,17 @@
+cff-version: 1.2.0
+message: >-
+  If you use ramanujan-qft, please cite it as below, and please also cite the
+  original methods it implements (see docs/PRIOR_ART.md).
+title: "ramanujan-qft: Ramanujan's Master Theorem, Mellin residue summation and arbitrary-precision Feynman integrals"
+version: 0.3.0a4
+license: MIT
+authors:
+  - given-names: Reetamshu
+repository-code: "https://github.com/reetanshuh1998/Ramanujan_master_theorem"
+url: "https://reetanshuh1998.github.io/Ramanujan_master_theorem/"
+keywords:
+  - Ramanujan's Master Theorem
+  - Mellin transform
+  - Feynman integrals
+  - arbitrary precision
+  - mpmath

ramanujan_qft-0.3.0a4/CONTRIBUTING.md

@@ -0,0 +1,64 @@
+# Contributing
+
+The aim is a reproducible scientific package built around Ramanujan and Mellin
+methods. Read [the capability table](docs/CAPABILITIES.md) and
+[the release plan](docs/RELEASE_PLAN.md) before proposing extensions.
+
+## Development
+
+```bash
+python -m pip install -e ".[test]"
+python -m pytest -q -m "not slow"
+python -m pytest -q                  # includes slow independent quadrature
+python tools/audit_sunset.py --output /tmp/sunset_audit.json
+```
+
+On Windows, choose a writable output path instead of `/tmp/sunset_audit.json`.
+Release tooling and documentation builds use Python 3.12; the numerical
+package supports Python 3.9 and later.
+
+Browser-console changes must pass `tools/check_browser_console.py` against the
+built documentation with its bundled wheel. The documentation workflow installs
+Playwright/Chromium and runs this check before deployment. To run it locally:
+
+```bash
+python -m pip install "playwright>=1.50,<2"
+python -m playwright install chromium
+python tools/check_browser_console.py --site docs/_build/html
+```
+
+The check needs network access to Pyodide's CDN. It executes the visible examples,
+independent numerical assertions, Reset, and the custom dependency-wheel path.
+
+Keep maintained examples in `examples/`, benchmarks in `benchmarks/`, and
+regression tests with their reference fixtures in `tests/`. Download external
+tools into ignored build directories. Do not commit generated comparison runs,
+compiled binaries, downloaded papers or unreviewed benchmark claims. The fixed
+`benchmarks/data/sunset_audit.json` report is intentional validation evidence.
+
+## Scientific changes
+
+Include the integral's normalization and domain, a derivation with primary
+references, and an independent numerical or analytic reference. A nonsingular
+exponent matrix alone does not establish convergence. Document pole collisions,
+error controls and resource limits. Keep distinct evaluation methods visible
+in the API and returned diagnostics; do not add silent quadrature fallbacks.
+
+For a bug, provide the smallest reproducing graph or function call, exact input
+strings, requested precision, installed version, actual result and independent
+expected value with its provenance. Add a regression test when fixing it.
+
+Tests should establish scientific behavior, numerical robustness or public API
+contracts. Timing measurements should include hardware/software versions,
+precision and a matched accuracy target. Avoid unconditional speed claims.
+
+## Pull requests and releases
+
+Describe the mathematical or numerical problem, resulting behavior, limitations
+and validation. The [scientific review packet](docs/SCIENTIFIC_REVIEW.md) lists
+open review questions for the new backends. Keep the fixed audit seed and record
+source hashes when regenerating benchmark data.
+
+Only maintainers publish releases. The [release checklist](docs/RELEASING.md)
+separates local preparation, hosted CI, external scientific review and public
+publication. Cite both the software version and the original methods.

ramanujan_qft-0.3.0a4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 In memory of Ramanujan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ramanujan_qft-0.3.0a4/MANIFEST.in

@@ -0,0 +1,20 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+include CITATION.cff
+include CONTRIBUTING.md
+include AUDIT.md
+include THIRD_PARTY_NOTICES.md
+recursive-include ramanujan_qft *.py
+recursive-include tests *.py *.csv *.json
+recursive-include tools *.py
+recursive-include notebooks *.ipynb
+recursive-include examples *.py *.txt *.rst
+recursive-include benchmarks *.py *.sh *.F
+recursive-include docs *.md *.py *.txt *.css *.html *.js
+prune docs/_build
+prune docs/auto_examples
+prune benchmarks/looptools/_build
+include benchmarks/data/sunset_audit.json
+include benchmarks/data/release_comparison.json
+include benchmarks/data/sunset_budgets.json