From 82ccf292ff323ee9e50bb771c819f83160b26cea Mon Sep 17 00:00:00 2001 From: Axel Hocks Date: Mon, 17 Aug 2026 00:31:41 +0200 Subject: [PATCH] Lead-Lag HL gegen Pepperstone neu gemessen: Pepperstone fuehrt, nicht HL User-Frage, ob der Hyperliquid-Kurs dem Broker vorauslaeuft und den Trend vorhersagen koennte. Im Projekt stand dazu ein Befund aus n=545; neu gerechnet auf 245.073 Ticks / 20,4 Tagen -- er reproduziert, deutlich schaerfer. KREUZKORRELATION der Renditen (k>0 = HL fuehrt, k<0 = Pepperstone fuehrt): Lag GESAMT H1 H2 k=-1 (~6 s, Pepperstone voraus) +0,455 +0,460 +0,447 k=0 (gleichzeitig) +0,505 +0,507 +0,503 k=+1 (~6 s, HL voraus) +0,020 +0,029 +0,005 Die Asymmetrie ist die Antwort: +0,455 gegen +0,020, Faktor 23. Beidhaelftig identisch. Kontrolle bestanden (k=0 bei +0,505 -- beide handeln erkennbar WTI). RICHTUNGSTEST, entkoppelt (nicht ueberlappende Fenster): ueber 12 Zellen (Vorlauf 6-30 s x Horizont 6-30 s x Schwelle 0,5-2,0 bp) liegt die Trefferquote zwischen 47,6 und 49,8 % -- durchweg am oder unter dem Muenzwurf; fuenf Zellen haben ein Intervall komplett unter 50 %. Oekonomisch entscheidet es ohnehin: die Oe-Bewegung in HL-Richtung betraegt +0,00 bis +0,14 bp (bei 30 s sogar -0,09), der Pepperstone-Spread ist ~2,7 bp -- 20- bis 270-mal so gross. URTEIL: HL taugt nicht als Vorlaufindikator. Deckt sich mit dem uebrigen Befund zu dieser Quelle (Orderbuch-Druck 0,2-1,0 bp, Modul am 06.08. entmachtet, Funding/Premium tragen nicht). Was HL bleibt: der 24/7-Kurs am Wochenende -- eine Verfuegbarkeits-, keine Vorhersage-Eigenschaft. Drei methodische Punkte, ohne die es anders ausgefallen waere: (1) 32 % der Zeit steht Pepperstone still (Wochenende) -- ein stehender Kurs erzeugt zwangslaeufig den Eindruck, HL laufe voraus. Nur die 65 % verwertbaren Ticks bei lebendem Broker gehen ein. (2) Gerechnet auf ROHEN Kursen: hl_mid + basis ist bei stehendem Broker zirkulaer (dokumentiert 02.08.). (3) Nur Renditen, nie Niveaus -- kointegrierte Preisreihen korrelieren immer nahe 1 und sagen nichts ueber Vorlauf. Grenze: Abtastung ~6 s, ein Vorlauf darunter waere unsichtbar -- praktisch aber nicht ausbeutbar (1-s-Poll, WireGuard, Market-Order). Nichts am Live-System geaendert. Co-Authored-By: Claude Opus 5 --- CLAUDE.md | 47 ++++++++++++ analyze_leadlag_hl.py | 168 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 215 insertions(+) create mode 100644 analyze_leadlag_hl.py diff --git a/CLAUDE.md b/CLAUDE.md index acf279c..4d1a1ec 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -5835,6 +5835,53 @@ er ist zugleich **trennschärfer** als die Einzel-Intervalle. Trefferquote im Ertrag** ein — es ist eine Komfort-, keine Edge-Entscheidung. Zahlen dafür liegen jetzt vor (1,3 → 0 % solcher Fälle, WR 36 → 56 %). +### ⚠⚠ LÄUFT HYPERLIQUID DEM BROKER VORAUS? NEIN — ES IST UMGEKEHRT (`analyze_leadlag_hl.py`, 2026-08-17) + +User-Frage. Im Projekt stand dazu ein Befund aus einer kleinen Stichprobe +(„Pepperstone führt, Peak k=−1 ≈ 6 s, 51 % Treffer, n=545"). Neu gerechnet auf +**245.073 Ticks / 20,4 Tagen** — und er reproduziert, deutlich schärfer. + +**KREUZKORRELATION der Renditen** (k>0 = HL führt · k<0 = Pepperstone führt): +| Lag | GESAMT | H1 | H2 | +|---|---|---|---| +| k=−1 (~6 s, **Pepperstone voraus**) | **+0,455** | +0,460 | +0,447 | +| k=0 (gleichzeitig) | +0,505 | +0,507 | +0,503 | +| k=+1 (~6 s, **HL voraus**) | **+0,020** | +0,029 | +0,005 | +⚠⚠ **Die Asymmetrie IST die Antwort: +0,455 gegen +0,020, Faktor 23.** Die +Pepperstone-Bewegung von jetzt sagt die HL-Bewegung 6 s später vorher; umgekehrt +sagt HL praktisch **nichts**. Beidhälftig identisch. +✅ Kontrolle bestanden: k=0 liegt bei +0,505 — beide handeln erkennbar WTI, die +Pipeline funktioniert. + +**RICHTUNGSTEST, entkoppelt** (nicht überlappende Fenster — die Cluster-Falle, +die im Projekt schon elf Hypothesen ausgelöst hat): über **12 Zellen** +(Vorlauf 6–30 s × Horizont 6–30 s × Schwelle 0,5–2,0 bp) liegt die Trefferquote +zwischen **47,6 und 49,8 %** — durchweg **am oder unter dem Münzwurf**. Fünf +Zellen haben ein Intervall **komplett unter 50 %**, d. h. wenn überhaupt, läuft +HL leicht GEGENläufig. +⚠ **Und die ökonomische Hürde entscheidet ohnehin:** die Ø-Bewegung in +HL-Richtung beträgt **+0,00 bis +0,14 bp** (bei 30 s sogar −0,09). Der +Pepperstone-Spread ist **~2,7 bp** — das ist **20- bis 270-mal** so groß. + +✅ **URTEIL: HL taugt NICHT als Vorlaufindikator.** Das deckt sich mit allem +Übrigen zu dieser Quelle: der Orderbuch-Druck ist mit 0,2–1,0 bp gegen ~3 bp +Kostenhürde gemessen, das Modul „Orderbuch" wurde am 06.08. wegen beidhälftig +negativer Prädiktivität entmachtet, und Funding/Premium tragen ebenfalls nicht. +⚠ **Was HL weiterhin kann und bleibt:** der 24/7-Kurs am **Wochenende**, wenn +Pepperstone geschlossen ist (Header-Anzeige + G/V-Schätzung) — das ist eine +Verfügbarkeits-, keine Vorhersage-Eigenschaft. + +⚠ **Drei methodische Punkte, ohne die das Ergebnis anders ausgefallen wäre:** +(1) **32 % der Zeit steht Pepperstone still** (Wochenende). Ein stehender Kurs +erzeugt zwangsläufig den Eindruck, HL laufe voraus — nur die 65 % verwertbaren +Ticks bei lebendem Broker gehen ein. (2) Gerechnet wurde auf **rohen** Kursen: +`hl_mid + basis` ist bei stehendem Broker zirkulär (dokumentiert 02.08.). +(3) Nur **Renditen**, nie Niveaus — zwei kointegrierte Preisreihen korrelieren +immer nahe 1 und sagen nichts über Vorlauf. +⚠ **Grenze:** die Abtastung liegt bei ~6 s, ein Vorlauf **unter** 6 s wäre +unsichtbar. Praktisch aber irrelevant — bei 1-s-Poll, WireGuard und Market-Order +ist er nicht ausbeutbar, und die Asymmetrie bei ±1 zeigt die Richtung bereits. + ### ✅ S/R-AUTO-CLOSE WIEDER AN (User-Entscheidung 2026-08-11) Frage war: „sollten wir Trades bei einem S/R-Bounce automatisch schliessen?" diff --git a/analyze_leadlag_hl.py b/analyze_leadlag_hl.py new file mode 100644 index 0000000..a3f5eaa --- /dev/null +++ b/analyze_leadlag_hl.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +"""Laeuft der Hyperliquid-Kurs dem Pepperstone-Kurs VORAUS? (User-Frage 2026-08-17) + +Wenn HL fuehrt, waere das eine echte Vorhersagequelle — und die einzige im +Projekt, die nicht aus dem Pepperstone-Kurs selbst abgeleitet ist. + +⚠ Im Projekt steht dazu bereits ein Befund („Pepperstone fuehrt, Peak k=-1 ~ 6 s, +HL-Richtung trifft nach 6 s zu 51 %, n=545"). Der stammt aus einer kleinen +Stichprobe; hier wird auf **245.000 Ticks / 20,4 Tagen** neu gerechnet. + +⚠⚠ DREI FALLEN, die das Ergebnis sonst erzeugen statt messen: + (1) **Geschlossener Broker.** 32 % der Zeit steht `mt5_mid` still (Wochenende). + Ein stehender Kurs erzeugt zwangslaeufig den Eindruck, HL laufe voraus. + -> Nur Ticks, bei denen sich MT5 in den letzten `_LEBT_S` bewegt hat. + (2) **Basis-Korrektur.** `hl_mid + basis` ist bei stehendem Broker ZIRKULAER + (dokumentiert 02.08.) — sie rekonstruiert den eingefrorenen MT5-Kurs. + -> Gerechnet wird auf ROHEN Kursen. + (3) **Niveaus statt Renditen.** Zwei kointegrierte Preisreihen korrelieren + immer nahe 1 — das sagt nichts ueber Vorlauf. + -> Nur RENDITEN, und keine ueber eine Datenluecke hinweg. + +⚠ Und die oekonomische Huerde: ein Vorlauf muss die Kosten schlagen. Der +Pepperstone-Spread liegt bei ~0,0225 $ auf ~82 $ = **~2,7 bp**. Ein Effekt von +0,2-1,0 bp (so lag der HL-Orderbuch-Befund) ist damit nicht handelbar. + +Aufruf: python analyze_leadlag_hl.py +""" +from __future__ import annotations + +import math +import random +import sqlite3 +import sys + +DB = r"C:\Users\ah\Downloads\HyperLiquid-WTI Trader\leadlag.db" +_LEBT_S = 180.0 # MT5 gilt als „lebt", wenn es sich so lange bewegt hat +_MAXLUECKE = 15.0 # Renditen nie ueber groessere Luecken bilden +_SPREAD_BP = 2.7 # Pepperstone-Spread ~0,0225 $ auf ~82 $ + + +def lade(): + db = sqlite3.connect(DB) + rows = db.execute( + "SELECT ts,hl_mid,mt5_mid FROM ticks WHERE hl_mid>0 AND mt5_mid>0 " + "ORDER BY ts").fetchall() + # (1) nur Phasen, in denen der Broker WIRKLICH laeuft + letzte_bewegung, vor = None, None + lebt = [] + for ts, hl, mt in rows: + if vor is None or mt != vor: + letzte_bewegung = ts + vor = mt + lebt.append(letzte_bewegung is not None and (ts - letzte_bewegung) <= _LEBT_S) + return rows, lebt + + +def renditen(rows, lebt): + """(ts, r_hl, r_mt5) — nur bei lebendem Broker und ohne Luecken-Spruenge.""" + out = [] + for i in range(1, len(rows)): + if not (lebt[i] and lebt[i - 1]): + continue + dt_ = rows[i][0] - rows[i - 1][0] + if not (0 < dt_ <= _MAXLUECKE): + continue + h0, h1 = rows[i - 1][1], rows[i][1] + m0, m1 = rows[i - 1][2], rows[i][2] + if h0 <= 0 or m0 <= 0: + continue + out.append((rows[i][0], (h1 - h0) / h0, (m1 - m0) / m0)) + return out + + +def korr(a, b): + n = len(a) + if n < 30: + return None + ma, mb = sum(a) / n, sum(b) / n + va = sum((x - ma) ** 2 for x in a) + vb = sum((x - mb) ** 2 for x in b) + if va <= 0 or vb <= 0: + return None + cov = sum((a[i] - ma) * (b[i] - mb) for i in range(n)) + return cov / math.sqrt(va * vb) + + +def kreuzkorr(rs, kmax=10): + """corr(r_hl[i], r_mt5[i+k]). k>0 = HL FUEHRT · k<0 = Pepperstone fuehrt.""" + hl = [x[1] for x in rs]; mt = [x[2] for x in rs] + out = [] + for k in range(-kmax, kmax + 1): + if k >= 0: + a, b = hl[:len(hl) - k], mt[k:] + else: + a, b = hl[-k:], mt[:len(mt) + k] + c = korr(a, b) + if c is not None: + out.append((k, c, len(a))) + return out + + +def richtung(rs, vor_n, nach_n, schwelle_bp): + """ENTKOPPELT: nicht ueberlappende Fenster. Bewegt sich HL im Fenster + deutlich, geht MT5 im NAECHSTEN Fenster in dieselbe Richtung?""" + tr = ges = 0 + bewegungen = [] + schritt = vor_n + nach_n + for i in range(0, len(rs) - schritt, schritt): # ⚠ nicht ueberlappend + h = sum(rs[i + j][1] for j in range(vor_n)) + if abs(h) * 1e4 < schwelle_bp: + continue + m = sum(rs[i + vor_n + j][2] for j in range(nach_n)) + ges += 1 + if (h > 0) == (m > 0): + tr += 1 + bewegungen.append(m * 1e4 * (1 if h > 0 else -1)) # bp in HL-Richtung + if ges < 20: + return None + r = random.Random(11) + bs = sorted(sum(1 if r.random() < tr / ges else 0 for _ in range(ges)) / ges + for _ in range(2000)) + ueberschuss = sum(bewegungen) / len(bewegungen) + return {"n": ges, "tr": 100 * tr / ges, + "lo": 100 * bs[50], "hi": 100 * bs[1950], "bp": ueberschuss} + + +def main(): + rows, lebt = lade() + rs = renditen(rows, lebt) + print(f"\n {len(rows)} Ticks · davon bei LEBENDEM Broker verwertbar: {len(rs)} " + f"({100*len(rs)/len(rows):.0f} %)") + print(f" Abtastung ~6 s → ein Lag-Schritt k entspricht ~6 Sekunden\n") + + mid = len(rs) // 2 + for lbl, teil in (("GESAMT", rs), ("H1", rs[:mid]), ("H2", rs[mid:])): + kk = kreuzkorr(teil) + best = max(kk, key=lambda x: abs(x[1])) + k0 = next(c for k, c, _ in kk if k == 0) + print(f" ── {lbl} (n={len(teil)}) ──") + print(f" gleichzeitig (k=0): r = {k0:+.4f} ← Kontrolle: beide handeln WTI") + print(f" staerkster Lag: k = {best[0]:+d} (~{best[0]*6:+d} s) " + f"r = {best[1]:+.4f} → " + f"{'HL fuehrt' if best[0] > 0 else 'PEPPERSTONE fuehrt' if best[0] < 0 else 'kein Vorlauf'}") + zeile = " Profil k=-3..+3: " + " ".join( + f"{k:+d}:{c:+.3f}" for k, c, _ in kk if -3 <= k <= 3) + print(zeile + "\n") + + print(" ── RICHTUNGSTEST (entkoppelt, nicht ueberlappend) ──────────────") + print(" „HL hat sich bewegt — geht Pepperstone danach mit?\"\n") + print(f" {'Vorlauf':>8}{'Horizont':>10}{'Schwelle':>10}{'n':>7}" + f"{'Treffer':>9}{'95-%-KI':>18}{'Ø Bewegung':>13}") + for vor_n, nach_n in ((1, 1), (1, 2), (2, 2), (5, 5)): + for s in (0.5, 1.0, 2.0): + r = richtung(rs, vor_n, nach_n, s) + if not r: + continue + flag = "" if r["lo"] <= 50 <= r["hi"] else (" ✅" if r["lo"] > 50 else " ❌") + print(f" {vor_n*6:>6}s{nach_n*6:>9}s{s:>9.1f}bp{r['n']:>7}" + f"{r['tr']:>8.1f}% [{r['lo']:>5.1f} … {r['hi']:>5.1f}]" + f"{r['bp']:>+11.2f}bp{flag}") + print(f"\n ⚠ Oekonomische Huerde: der Pepperstone-Spread ist ~{_SPREAD_BP} bp.") + print(" Eine Ø-Bewegung darunter ist nicht handelbar, egal wie die " + "Trefferquote aussieht.") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())