So funktioniert LotteryCortex

1. Bayessche Frequenz-Shrinkage

Wie oft eine Zahl gezogen wurde, korrigiert um die verfügbare Datenmenge.

• Reine Rohfrequenz überschätzt 'heiße' Zahlen, wenn die Historie kurz ist. Wir legen einen Dirichlet-Prior darüber mit automatischer Alpha-Schätzung (dirichletAlphaAuto, Method-of-Moments auf der empirischen Varianz).
• Das Ergebnis ist eine Posterior-Wahrscheinlichkeit pro Zahl, die zu 1/N (uniform) schrumpft, solange die Historie klein ist, und der echten Frequenz folgt, sobald genügend Ziehungen vorliegen.

p̂(n) = (count(n) + α) / (totalDraws · k + α · N)

src/lib/engine-core.ts · src/lib/advanced-stats.ts

2-4. Zeitgewichtetes EMA mit mehreren Halbwertszeiten

Neuere Ziehungen zählen mehr als alte — drei Horizonte parallel.

• Für jede Ziehung i vom Ende vergeben wir Gewicht w_i = 0.5^(i / H). Wir betreiben drei EMAs parallel mit H = 8, 26 und 78 Ziehungen (kurz/mittel/lang).
• Kurze Halbwertszeit erfasst 'Hot Streaks'. Lange Halbwertszeit verhindert Überreaktion auf eine seltsame Ziehung. Der Ensemble-Blender entscheidet, wie viel Gewicht jeder Horizont pro Lotterie erhält — getunt via Grid-Search.

EMA_H(n) = Σ_i  0.5^(i/H) · 1[n ∈ draw_i]

src/lib/engine-core.ts (HALF_LIVES = [8, 26, 78])

5. PMI-Cooccurrence-Boost

Welche Zahlen erscheinen häufiger zusammen, als der Zufall vorhersagen würde?

• Wir berechnen Pointwise Mutual Information: PMI(a,b) = log [P(a,b) / (P(a)·P(b))]. Positives PMI = das Paar erscheint häufiger zusammen als bei Unabhängigkeit erwartet.
• Pro Kandidaten-Zahl summieren wir das PMI mit allen Zahlen der jüngsten Ziehung. Das ergibt ein 'Follow-the-Pattern'-Signal ohne Overfitting: PMI ist begrenzt und wird auf ±3 geclippt.

score_PMI(n) = Σ_{m ∈ lastDraw}  clip(log[P(n,m) / (P(n)P(m))], ±3)

src/lib/engine-core.ts

6. Markov-Übergangswahrscheinlichkeiten

Aus der letzten Ziehung schätzen wir die Übergangswahrscheinlichkeit zur nächsten Zahl.

• Wir bauen eine N×N-Übergangsmatrix T mit T[a,b] = P(b in draw_t+1 | a in draw_t), geschätzt mit Laplace-Glättung.
• Für den Live-Score nehmen wir den Mittelwert von T[a, n] über alle a in der letzten Ziehung. Kalte Zahlen bleiben nicht ewig kalt; dieser Schritt modelliert endliches Gedächtnis.

src/lib/engine-core.ts

7. Ensemble & getunte Gewichte

Die sechs Signale werden via gewichteter Rang-Aggregation zusammengeführt.

• Jedes Signal wird in Rang-Perzentile [0, 1] umgewandelt. Dann linear kombiniert mit Gewichten w = (w_bayes, w_ema1, w_ema2, w_ema3, w_pmi, w_markov). Default uniform; pro Lotterie via Grid-Search + ROI-Validierung getunt.
• Rang-Aggregation ist robust gegen Skalenunterschiede zwischen Signalen und verhindert, dass ein Ausreißer-Score das Ensemble dominiert.

score(n) = Σ_s  w_s · rank_s(n) / N

src/lib/engine-core.ts · src/lib/engine-tuning.functions.ts

8. Meta-Learner (logistische Regression, 12 Features)

Eine lotteriespezifische Logreg lernt die optimale nichtlineare Kombination der Engine-Signale.

• Feature-Vektor (12 Dim.): die 6 Engine-Ränge + Interaktionen (EMA1·PMI, Bayes·Markov, EMA3·Bayes) + Recency + Hot Streak (Erscheinungen in den letzten 10) + Cold Streak (aufeinanderfolgende Abwesenheiten).
• Training: L2-regularisierte Logreg mit SGD über die gesamte Historie. Verlust = Log-Loss auf Label '1, wenn die Zahl in der nächsten Ziehung erschien'. Abwärtskompatibel: alte 9-Dim-Modelle funktionieren weiter.

P(n in nächster Ziehung) = σ(w · features(n) + b)

src/lib/meta-learner.ts

9. Gradient-Boosted Decision Stumps

Zweiter Meta-Learner, der nichtlineare Interaktionen ohne neuronales Netz erfasst.

• Mini-LightGBM-Clone: iterative Decision Stumps auf den Residuen. Jeder Stump wählt 1 Feature + Threshold, der den Loss maximal reduziert; wir addieren lr · stump.output zur aktuellen Vorhersage.
• Output ist JSON-serialisierbar und wird neben der Logreg in engine_config.meta_weights.gbm gespeichert. Der Stacked-Blender kombiniert beide.

src/lib/gbm.ts

10. Out-of-Fold Stacking-Blender

Logreg + GBM werden ohne Daten-Leakage kombiniert.

• Wir teilen die Historie in 5 stratifizierte Folds. Pro Fold trainieren wir Logreg + GBM auf 4 Folds und sagen auf dem gehaltenen Fold voraus. Diese OOF-Vorhersagen werden Eingaben für eine zweite Logreg-Meta-Schicht, die die optimale Gewichtung lernt.
• Ergebnis: kalibrierbare Wahrscheinlichkeiten, ohne dass der Meta-Learner seine eigenen Trainingsdaten wiedersieht.

src/lib/advanced-stats-v3.ts · src/lib/nested-cv.ts

11. Isotonische & Platt-Kalibrierung

Rohe Modellwahrscheinlichkeiten werden monotonisiert, damit sie tatsächlich Wahrscheinlichkeiten sind.

• Platt-Skalierung passt ein 1-Parameter-Sigmoid über die Rohscores auf Validierungsdaten. Isotonische Regression (Pool-Adjacent-Violators) ist eine nicht-parametrische Version, die nur Monotonie erzwingt.
• Wir messen Expected Calibration Error (ECE) auf Out-of-Fold-Vorhersagen; der Kalibrator mit dem geringsten ECE geht in Produktion.

src/lib/advanced-stats-v2.ts · src/lib/advanced-stats-v3.ts

12. Anti-Clustering Ticket-Generator

Kandidaten-Tickets werden gesampelt, schlechte Strukturen verworfen.

• Wir ziehen Zahlen proportional zum Ensemble-Score (Softmax mit pro Lotterie getunter Temperatur τ). Jeder Kandidat wird validiert:
• • max. 3 aus derselben Dekade (Anti-Clustering),
• • Summe innerhalb der historischen IQR-Bande (keine reinen Low- oder High-Tickets),
• • Paritäts-Split innerhalb empirischer Verteilung,
• • keine arithmetische Folge von ≥4 aufeinanderfolgenden Zahlen.
• Abgelehnte Kandidaten werden erneut gesampelt, bis wir N gültige Tickets haben.

src/lib/engine-core.ts (generateAntiClusterTickets)

13. Greedy submodulare Portfolio-Auswahl

Aus Tausenden Kandidaten wählen wir K Tickets, die gemeinsam maximal abdecken.

• Problem: Wähle K Tickets, die die Summe von P(Zahl gezogen) über die gewählten Tickets maximieren, mit abnehmenden Erträgen für Overlap.
• Submodulare Funktionen haben eine Optimalitätsgarantie von 1 − 1/e ≈ 63 % für die Greedy-Lösung. Pro Iteration wählen wir das Ticket mit dem größten marginalen Zugewinn und diskontieren abgedeckte Zahlen mit Faktor 0.4.

f(S ∪ {t}) − f(S) = Σ_{n ∈ t}  remain[n] · (½ bei Bonus)

src/lib/portfolio-optimizer.ts

14. Markowitz Min-Varianz-Portfolio

Neben Abdeckung minimieren wir gegenseitige Korrelation zwischen Tickets.

• Korrelation zwischen Ticket i und j ≈ |overlap| / √(|t_i|·|t_j|). Greedy: wähle stets das Ticket mit höchstem EV minus λ · Σ corr(aktuell, gewählt).
• Risiko-Aversion λ ist ein tunbarer Parameter (Default 1.2). Höheres λ = mehr Diversifikation, geringerer erwarteter Score pro Ticket, aber geringere Varianz der gesamten Portfolio-Auszahlung.

util(t) = EV(t) − λ · Σ_{j ∈ picked}  overlap(t, j)

src/lib/markowitz.ts

15. Shared-Jackpot Popularitäts-Korrektur

Ein Treffer auf eine 'populäre' Kombination wird mit mehr Gewinnern geteilt.

• popularityScore() zählt: % Zahlen ≤ 31 (Geburtstage), % in der unteren Hälfte, aufeinanderfolgende Reihen ≥3, arithmetische Progressionen, gleiche Endziffern, Kreuze/Diagonalen auf dem Spielschein.
• Daraus schätzen wir die Anzahl der Mitgewinner und wenden adjustJackpotForSharing() an: der EV im Gating-Schritt nutzt die erwartete Auszahlung nach Teilung, nicht den Brutto-Jackpot.

src/lib/popularity.ts

16. Jackpotbewusstes EV-Gating

'Spielen' nur empfehlen, wenn der Erwartungswert positiv ist.

• EV = Σ_tier P(tier) · payout(tier) − ticketCost. P(tier) ist exakt aus kombinatorischen Quoten (Binomialkoeffizienten pro Lotterieformel). Payout(tier) kommt aus PRIZE_TIERS — für die Jackpot-Klasse ersetzt durch den aktuellen Jackpot (nach Popularitäts-Teilung).
• Wir berechnen auch den Break-Even-Jackpot: den Betrag, bei dem EV = 0. Darunter zeigt die UI '⏸ Aussetzen'.
• Das Kelly-Kriterium bestimmt optionale Einsatzgröße für Abonnenten, die mehrere Wochen planen.

EV = Σ_t  P(t) · payout(t) − cost   |   break-even = (cost − Σ_{t≠jp} P(t)·payout(t)) / P(jp)

src/lib/ev-gating.ts

17. Regime-Erkennung (CUSUM + 2-State-HMM + Particle-Filter)

Erkennt, ob der Ziehungsgenerator selbst sich verschoben hat.

• CUSUM verfolgt pro Zahl eine kumulierte Abweichung von der erwarteten Frequenz und alarmiert beim Überschreiten der Schwelle h.
• Ein 2-State-HMM (hot/cold) wird mit Baum-Welch auf der Frequenz-Zeitreihe trainiert; Übergänge werden Viterbi-dekodiert.
• Ein Sequential-Monte-Carlo-Particle-Filter hält 200 Partikel über dem versteckten Regime-State und liefert eine Soft-Probability pro Ziehung.
• Bei Regime-Shift erhält die kurze EMA temporär mehr Gewicht (Online-Adaption).

src/lib/advanced-stats-v2.ts · src/lib/advanced-stats-v3.ts

18. Statistische Erweiterungen Stufe 3

Conformal Prediction, Negative-Binomial-Gap-Modell, Copulas, Shapley und mehr.

• • Split-Conformal-Prediction → Bandbreite auf Meta-Probs mit garantierter Coverage.
• • Dirichlet-Multinomial-Posterior über die gesamte Ziehung (nicht nur pro Zahl).
• • Negative-Binomial-Gap-Modell für Überdispersion zwischen Erscheinungen.
• • Gauß-Copula für Paar-Abhängigkeiten, die PMI verpasst.
• • Permutationstest pro Signal (Label-Shuffle) → p-Wert für 'besser als Zufall'.
• • SHAP-Attribution pro Ticket (lineare Approximation) → erklärt, warum dieses Ticket gewählt wurde.
• • CVaR / Expected Shortfall über Portfolio-Auszahlungen.
• • Anderson-Darling Goodness-of-Fit auf Uniformität.

src/lib/advanced-stats-v2.ts · src/lib/advanced-stats-v3.ts

19. Auto-Tuner: Nested CV + Grid-Search

Wöchentliches pg_cron überarbeitet Engine-Gewichte und Meta-Modelle pro Lotterie.

• Äußere 5-Fold stratifizierte CV → Out-of-Sample-ROI-Schätzung. Innere CV → Preset-Auswahl.
• Grid-Search über 6-Dim Gewichts-Simplex (BMA-gewichtet) + Halbwertszeit-Presets (HALF_LIFE_GRID). Pro Konfiguration: K Tickets pro Fold simulieren, mit Prize-Tiers bewerten, ROI mit 95 % Bootstrap-CI aggregieren.
• Ein neues Preset wird nur akzeptiert, wenn CI-low > Baseline-ROI (kein Glückstreffer).
• Ergebnisse landen in engine_config (DB) und sind sofort live für alle Abonnenten.

src/lib/engine-tuning.functions.ts · src/routes/api/public/hooks/auto-tune.ts

20. Thompson-Sampling-Bandit (Online-Preset-Auswahl)

Zwischen Auto-Tunes schaltet ein Bandit live zwischen Presets basierend auf aktueller ROI.

• Pro Preset führen wir einen Beta(α, β)-Posterior: α = Gewinne (ROI > 0), β = Verluste. Bei jeder Produktion-Pick samplen wir aus jeder Beta und wählen den höchsten Sample.
• Updates kommen vom Tracker: sobald eine Ziehung vorbei ist, bekommen die gewählten Presets ihr α oder β +1.
• Ergebnis: auch ohne vollständige Neu-Tunung konvergiert das System online zum besten Preset.

pick = argmax_p  Beta(α_p, β_p).sample()

src/lib/bandit.ts

21. Walk-Forward-Backtest

Jede Strategie wird ohne Zukunftswissen geprüft (kein Leakage).

• Ab MIN_HISTORY iterieren wir Ziehung für Ziehung. Pro Ziehung bauen wir das Modell NUR aus Ziehungen davor, generieren N Tickets und bewerten gegen die echte Ziehung.
• Wir aggregieren Treffer pro Tier, mittlere ROI, kumulierte P&L sowie eine Random-Baseline zur Kontrolle. Eine Strategie 'gewinnt' nur, wenn ihr CI-Band über dem Zufall liegt.

src/lib/backtest.functions.ts

22. Wheeling-Systeme (Covering Designs)

Mathematische Garantie: bei M korrekten Zahlen im Pool stets ein Y-aus-X-Gewinn.

• Wir implementieren Full Wheels, Key Wheels und Abbreviated Covering Designs. Für jedes (Pool-Größe, Ticket-Größe, Garantie) wählen wir die kombinatorisch optimale Menge.
• Der Wheel-Generator kombiniert mit dem Portfolio-Optimizer: Kandidaten werden zuerst gewheelt, dann submodulär ausgewählt.

src/lib/wheel.functions.ts