Sync with GitHub, license metadata from LICENSE files, commercial license notice

metadata license: None -> other (sovereign-source-license)
README: License section kept (already accurate)

README.md

@@ -1,333 +1,341 @@
-<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>
+---
+license: other
+license_name: sovereign-source-license
+license_link: https://huggingface.co/Snapkitty/quantabeta-core/blob/main/LICENSE
+tags:
+- snapkitty
+---
+
+<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>