# QuantaBeta Core
**Sovereign Deterministic Alpha Mining**
[](./LICENSE)
[](./LICENSE)
[](#arithmetic-invariant-no-floats-ever)
[](#layer-1-symbolic-feature-algebra)
[](#layer-2-arithmetic-invariant-search)
[](#layer-5-formal-validation)
[](#layer-6-worm-factor-registry)
[](./LICENSE)
---
*LLMs generate coherent noise, not alpha.*
*This pipeline generates alpha from number theory.*
---
## What Is This?
QuantaBeta Core is a sovereign quantitative finance pipeline that replaces the standard "LLM research agent → code gen → backtest" loop with **arithmetic invariant search → proof-carrying code → formally validated factors**.
The central claim: **market alpha is arithmetic structure, not statistical pattern**. Ramanujan partition congruences, Hecke operator eigenvalues, and Rogers-Ramanujan identities are not metaphors. They are executable filters that select for genuine predictive structure in return series — structure that persists because it is grounded in number theory, not in learned correlations.
Every result is deterministic. Every computation is exactly rational. Every factor is WORM-sealed. Every acceptance criterion is a theorem, not a threshold.
---
## The Arithmetic Invariant — No Floats. Ever.
The founding constraint of this codebase: `f64` is banned at every layer.
This is not a style preference. It is a mathematical requirement.
Standard quant libraries (NumPy, pandas, VectorBT) use IEEE 754 floating-point. Float arithmetic is non-associative, non-commutative under rounding, and platform-dependent. Two machines running the same backtest can produce different results. A factor that "works" in development may fail in production because the rounding modes differ.
QuantaBeta uses:
| Computation | Type | Library |
|---|---|---|
| Return series features | `rug::Rational` | GMP arbitrary-precision |
| PnL accounting | `rug::Integer` | GMP exact integer |
| Entropy computation | `rug::Float` with `Round::Down`/`Round::Up` | MPFR directed rounding |
| Sharpe ratio | Rational interval `[L, U]` | Exact bounds |
| Symbolic entropy | `SymLog2 { coeff: Rational, base: Integer }` | No evaluation |
The result: given the same input, the pipeline produces bitwise-identical output on every machine, every run, forever.
---
## The Mathematical Foundation
### Ramanujan Partition Theory
The partition function `p(n)` counts the number of ways to write n as an ordered-indifferent sum of positive integers. It appears in three roles:
**1. Complexity bound.** `p(n)` bounds the search space for features of complexity n. Since `p(n) ~ exp(π√(2n/3)) / (4n√3)`, the search space is super-polynomial but enumerable for small n.
**2. Volatility measure.** `compute_partition_volatility` replaces variance with a partition-entropy: given return bucket frequencies `(f₁, ..., fₖ)`, the volatility is `Σ p(fᵢ)/p(window)`. Partition numbers measure "how many ways can this frequency distribution arise" — higher partition entropy means more combinatorial uncertainty.
**3. Congruence filter.** Ramanujan's exact congruences:
- `p(5k+4) ≡ 0 (mod 5)` for all k ≥ 0 — verified in code, tested against OEIS A000041
- `p(7k+5) ≡ 0 (mod 7)` for all k ≥ 0 — verified in code
A factor whose complexity index falls at a congruence residue is flagged as having low informational content. This is an arithmetic sieve, not a heuristic.
### Hecke Operators
The Hecke operator T_n acts on a modular form f by:
```
(T_n f)_m = Σ_{d | gcd(n,m)} d^(k-1) * a_{nm/d²}
```
In the pipeline, `hecke_cross_correlation` computes `⟨T_n(series_A), series_B⟩`. If two return series arise from instruments related by an Eichler-Shimura construction — i.e., their L-functions share a newform — this inner product is large at the corresponding Hecke eigenvalue and small otherwise. This is the cross-predictability signal.
The Deligne bound `|a_p(f)| ≤ 2p^((k-1)/2)` (Fields Medal 1978) bounds the eigenvalues. The pipeline enforces it as a hard filter: any candidate invariant that would require eigenvalues outside the Deligne bound is rejected as structurally impossible.
**Connection to PAR-011 (Jacobian Conjecture):** The golden ratio φ = (1+√5)/2 that appears in the Jacobian proof via Jordan algebras also appears as the characteristic eigenvalue bound for the simplest Hecke operator T_2 on weight-2 forms. Four independent mathematical contexts, one structure. See: [Zenodo 10.5281/zenodo.21727363](https://doi.org/10.5281/zenodo.21727363).
### Rogers-Ramanujan Identities
The first Rogers-Ramanujan identity:
```
Σ_{n≥0} q^(n²) / (q;q)_n = Π_{n≥0} 1/((1-q^(5n+1))(1-q^(5n+4)))
```
This connects the combinatorial structure of sequences with gap constraints to the Ramanujan partition congruences — factors selected by the `RamanujanCong(5, 4)` invariant live precisely in the residue classes `5n+1` and `5n+4` of the product side.
### True Entropy and the Ω = 0.21 Threshold
Shannon entropy: `H(P) = log₂(N) - (1/N) Σ cᵢ log₂(cᵢ)`
H is an algebraic number — a linear combination of logs of integers. The pipeline computes it three ways:
- **Point:** MPFR at 256-bit precision, correctly rounded
- **Interval:** Guaranteed bounds `[L, U]` with `Round::Down` / `Round::Up`
- **Symbolic:** `H = (1/N)log₂(N) + Σ(-cᵢ/N)log₂(cᵢ)` — no evaluation, pure algebra
The `entropy_coherent(Counts, 0.21)` predicate in `logic/entropy.pl` gates every factor. A factor whose residuals have entropy below 0.21 bits concentrates ≥ 96.6% of its probability mass on a single outcome. This threshold mirrors the Ω field coherence gate in the SnapKitty constellation — the system stays coherent when its entropy is below 0.21.
---
## Pipeline
```
Market Data
|
| rug::Rational — no f64 past this point
v
┌─────────────────────────────────────────────────────────────────┐
│ LAYER 1: SYMBOLIC FEATURE ALGEBRA │
│ crates/quantabeta-core/src/features.rs │
│ │
│ compute_partition_volatility(returns, window) │
│ → entropy of partition frequencies over return buckets │
│ → exact Rational output, deterministic │
│ │
│ hecke_cross_correlation(series_a, series_b, level) │
│ → ⟨T_n(series_A), series_B⟩ exact rational inner product │
│ → measures Hecke eigenvalue overlap between instruments │
└──────────────────────────────┬──────────────────────────────────┘
|
v
┌─────────────────────────────────────────────────────────────────┐
│ LAYER 2: ARITHMETIC INVARIANT SEARCH │
│ haskell/src/Quantabeta/InvariantSearch.hs │
│ │
│ Enumerates typed candidate invariants: │
│ HeckeCorr(level, weight) — prime levels, even weights │
│ PartitionVol(window) — standard trading windows │
│ RamanujanCong(modulus, residue) — mod 5, 7, 11 │
│ │
│ wellTyped filter: Hecke weights must be even, windows ≤ 252 │
│ Replaces: LLM research agent │
│ Outputs: SGML