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>
This commit is contained in:
Axel Hocks
co-authored by
Claude Opus 5
Claude Opus 5
parent
276c8c7f07
commit
82ccf292ff
@@ -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())
|
||||
Reference in New Issue
Block a user