Metadata: discovery tags (collection, languages)

038dd27 verified 2 days ago

19.9 kB

	---
	license: other
	license_name: sovereign-source-license
	license_link: https://huggingface.co/Snapkitty/quantabeta-core/blob/main/LICENSE
	tags:
	- snapkitty
	- formal-verification
	- lean4
	- haskell
	---

	<div align="center">

	<img src="./docs/quantabeta-banner.gif" width="100%" alt="QuantaBeta Core — Sovereign Deterministic Alpha Mining"/>

	<img src="./docs/quantabeta-poster.png" width="100%" alt="QuantaBeta Core Architecture"/>


	# QuantaBeta Core

	Sovereign Deterministic Alpha Mining

	[![License: Sovereign Source v1.0](https://img.shields.io/badge/License-Sovereign_Source_v1.0-black?style=flat-square)](./LICENSE)
	[![BSL](https://img.shields.io/badge/BSL-2029--01--01_→_AGPL--3.0-purple?style=flat-square)](./LICENSE)
	[![Float](https://img.shields.io/badge/f64-BANNED-red?style=flat-square)](#arithmetic-invariant-no-floats-ever)
	[![Rust](https://img.shields.io/badge/Rust-rug::Rational-orange?style=flat-square)](#layer-1-symbolic-feature-algebra)
	[![Haskell](https://img.shields.io/badge/Haskell-LiquidHaskell-blue?style=flat-square)](#layer-2-arithmetic-invariant-search)
	[![Lean 4](https://img.shields.io/badge/Lean_4-zero_sorry-brightgreen?style=flat-square)](#layer-5-formal-validation)
	[![WORM](https://img.shields.io/badge/WORM-sealed-brightgreen?style=flat-square)](#layer-6-worm-factor-registry)
	[![Trust](https://img.shields.io/badge/Trust-EIN_42--697643-gold?style=flat-square)](./LICENSE)

	---

	LLMs generate coherent noise, not alpha.

	This pipeline generates alpha from number theory.

	</div>

	---

	## 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 <claim> tags for claimguard oracle │
	└──────────────────────────────┬──────────────────────────────────┘
	\|
	v
	┌─────────────────────────────────────────────────────────────────┐
	│ LAYER 3: FACTOR SYNTHESIS │
	│ logic/factor_synthesis.pl │
	│ │
	│ Prolog DCG: invariant AST → compilable Rust code │
	│ DCG grammars are provably correct — generated code is │
	│ structurally guaranteed syntactically valid │
	│ Content-addressed factor ID from AST hash │
	│ Emits Bifrost JSON audit manifest │
	└──────────────────────────────┬──────────────────────────────────┘
	\|
	v
	┌─────────────────────────────────────────────────────────────────┐
	│ LAYER 4: DETERMINISTIC BACKTEST │
	│ crates/quantabeta-core/src/backtest.rs │
	│ │
	│ Lamport logical clock — not wall time. Order is provable. │
	│ PnL = Σ(pos_t × (price_{t+1} - price_t)) - fees │
	│ All arithmetic: rug::Integer (exact) │
	│ Sharpe = Rational interval [L, U] — not a point estimate │
	│ SHA-256 audit hash seals exact PnL + Sharpe bounds │
	└──────────────────────────────┬──────────────────────────────────┘
	\|
	v
	┌─────────────────────────────────────────────────────────────────┐
	│ LAYER 5: FORMAL VALIDATION │
	│ lean/Quantabeta/Validation.lean │
	│ │
	│ IsRobust(f, baseline, ε) := │
	│ ∀ noise : \|noise_i\| ≤ ε.epsilon, │
	│ pnl(f, baseline + noise) > 0 │
	│ │
	│ A universally quantified statement over ALL perturbations. │
	│ Not Sharpe > 1.5. A theorem. │
	│ Ramanujan congruence axiom + Deligne bound axiom included. │
	└──────────────────────────────┬──────────────────────────────────┘
	\|
	v
	┌─────────────────────────────────────────────────────────────────┐
	│ LAYER 6: WORM FACTOR REGISTRY │
	│ crates/quantabeta-core/src/worm.rs │
	│ │
	│ Each FactorArtifact carries: │
	│ arithmetic_invariant — the number-theoretic basis │
	│ proof_hash — Lean 4 proof term hash │
	│ code_hash — Rust WASM hash │
	│ sharpe_interval — [L, U] rational bounds │
	│ entropy_signature — true entropy of residuals │
	│ operator — "Ahmad_Ali_Parr" │
	│ previous_seal — SHA-256 chain link │
	│ │
	│ verify_chain() checks entire chain in O(n) │
	│ → Connects to snap-os/bifrost for Blake3+Ed25519 sealing │
	└─────────────────────────────────────────────────────────────────┘
	```

	---

	## Cross-Cutting: True Entropy

	`crates/true-entropy` is used across all layers as the exact entropy primitive.

	```rust
	// Point estimate — MPFR 256-bit, correctly rounded
	let h = shannon_entropy_exact([3u64, 1, 2, 4], 256);

	// Guaranteed interval — directed rounding
	let (lo, hi) = shannon_entropy_interval([3u64, 1, 2, 4], 256);
	// Invariant: lo ≤ true_entropy ≤ hi, always

	// Symbolic — no evaluation, pure algebra
	let sym = shannon_entropy_symbolic([3u64, 1, 2, 4]);
	// Returns: [SymLog2{coeff: 1/10, base: 10}, SymLog2{coeff: -3/10, base: 3}, ...]
	// H = (1/10)log₂(10) + (-3/10)log₂(3) + (-1/10)log₂(1) + ...
	```

	The `entropy_coherent(Counts, 0.21)` Prolog predicate calls this layer and gates the entire pipeline.

	---

	## What Is Built

	\| Layer \| File \| What It Does \| Tests \|
	\|-------\|------\|-------------\|-------\|
	\| 1 \| `crates/quantabeta-core/src/features.rs` \| Partition volatility + Hecke cross-correlation, exact rational \| OEIS A000041 p(0..10), determinism \|
	\| 1 \| `crates/ramanujan-ops/src/partition.rs` \| HRR partition p(n), Ramanujan congruences mod 5 and 7 \| OEIS A000041 p(0..20), congruences \|
	\| 1 \| `crates/ramanujan-ops/src/hecke.rs` \| T_n double-coset formula, Deligne bound \| T_1 identity, Deligne bound \|
	\| 1 \| `crates/ramanujan-ops/src/qseries.rs` \| q-integers, q-Pochhammer, Rogers-Ramanujan \| RR identity at q=1/10 \|
	\| cross \| `crates/true-entropy/src/lib.rs` \| Exact/interval/symbolic Shannon entropy, MPFR \| Uniform=1bit, certain=0, interval contains point \|
	\| cross \| `haskell/src/Verified/Entropy.hs` \| Symbolic entropy HOC, rational log₂ intervals, partition entropy \| Type-checked \|
	\| 2 \| `haskell/src/Quantabeta/InvariantSearch.hs` \| Typed invariant enumeration, Deligne+IC checks, SGML output \| wellTyped filter \|
	\| 3 \| `logic/factor_synthesis.pl` \| Prolog DCG → Rust code gen, Bifrost manifest \| Hecke + partition synthesis \|
	\| 3 \| `logic/entropy.pl` \| Bifrost FFI bridge, Ω coherence gate, WORM audit \| Integration (requires FFI) \|
	\| 4 \| `crates/quantabeta-core/src/backtest.rs` \| Lamport clock, integer PnL, rational Sharpe interval \| Determinism test \|
	\| 5 \| `lean/Quantabeta/Validation.lean` \| Formal robustness ∀ ε-bounded noise \| trivially_robust_increasing \|
	\| 6 \| `crates/quantabeta-core/src/worm.rs` \| SHA-256 append-only WORM chain \| Chain integrity \|

	---

	## Run

	```
	cargo test --workspace
	```

	Tests verify:
	- `p(0)..p(20)` match OEIS A000041 exactly
	- `p(5k+4) ≡ 0 (mod 5)` holds for k=0..10 (Ramanujan)
	- `p(7k+5) ≡ 0 (mod 7)` holds for k=0..5 (Ramanujan)
	- Deligne bound `\|a_2\| ≤ 64` satisfied for Delta function
	- Rogers-Ramanujan identity verified at q=1/10 to order 20
	- Shannon entropy `[1,1]` = exactly 1 bit at 256-bit precision
	- Interval `[L,U]` always contains point estimate
	- Backtest determinism: same ticks → same PnL → same audit hash
	- WORM chain integrity verified after 2 appends

	---

	## Connection to SnapKitty Stack

	\| Repo \| Role \|
	\|------\|------\|
	\| [`snapkitty-clojure-lisp-bridge`](https://github.com/SNAPKITTYWEST/snapkitty-clojure-lisp-bridge) \| claimguard oracle gates every factor claim via SGML before WORM seal \|
	\| [`snap-os/bifrost`](https://github.com/SNAPKITTYWEST/snap-os) \| Production WORM — upgrade `worm.rs` SHA-256 to Blake3+Ed25519 \|
	\| [`the-49th-call`](https://github.com/SNAPKITTYWEST/the-49th-call) \| Abjad-Swarm Born rule weighting uses φ^(-i) — same φ as Hecke bounds \|
	\| [`jacobian-formal`](https://github.com/SNAPKITTYWEST/jacobian-formal) \| PAR-011 Jordan operator uses the same φ. Four independent contexts, one structure. \|
	\| [`gkn-i4-e7-lean`](https://github.com/SNAPKITTYWEST/gkn-i4-e7-lean) \| I₄ quartic invariant structure mirrors partition function algebra \|

	---

	## The φ Convergence

	The golden ratio φ = (1+√5)/2 appears independently in four formal contexts across this constellation:

	\| Context \| How \| Repo \|
	\|---------\|-----\|------\|
	\| PAR-011 Jordan fixed-point operator \| T(ρ) = φ⁻¹UρU† + φ⁻²ρ, drives commutativity \| jacobian-formal \|
	\| Hecke eigenvalue bound \| Characteristic eigenvalue of T_2 on weight-2 forms \| quantabeta-core \|
	\| Abjad-Swarm Born rule \| Agent weighting φ^(-i), golden ratio decay per level \| the-49th-call \|
	\| I₄ quartic invariant \| E₇ symmetry structure \| gkn-i4-e7-lean \|

	This is not numerology. It is convergence across independent formal derivations. Each is machine-verifiable.

	---

	## Prior Art

	\| Record \| DOI \| Date \|
	\|--------\|-----\|------\|
	\| Jordan Spectral Transformer (φ operator origin) \| [10.5281/zenodo.21443609](https://doi.org/10.5281/zenodo.21443609) \| 2026-07-19 \|
	\| PAR-011: Jacobian Conjecture via Jordan Algebras \| [10.5281/zenodo.21727363](https://doi.org/10.5281/zenodo.21727363) \| 2026-07-31 \|

	WORM anchor: `github.com/SNAPKITTYWEST/quantabeta-core`

	---

	## License

	Sovereign Source License v1.0 — Business Source License variant.

	- Non-production use: Free. Research, education, evaluation, personal projects.
	- Production use (live or paper trading, capital > $1,000): Requires commercial license until 2029-01-01.
	- After 2029-01-01: AGPL-3.0.

	The IP is held by Bel Esprit D'Accord Irrevocable Trust (EIN 42-697643). Unauthorized commercial use is interference with trust property.

	See [LICENSE](./LICENSE) for full terms including WORM chain integrity clause, namespace protection, and prior art anchors.

	Commercial licensing: [ahmedparr93@gmail.com](mailto:ahmedparr93@gmail.com) \| [collectivekitty.com](https://collectivekitty.com)

	---

	<div align="center">

	Built by: Ahmad Ali Parr + Claude Code
	Trust: Bel Esprit D'Accord Irrevocable Trust
	Constellation: [SNAPKITTYWEST](https://github.com/SNAPKITTYWEST)

	`Ω = TRUST ∧ CODE`

	</div>