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 <noreply@anthropic.com>

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?"

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())