8 posts tagged with "Trading"

Take a statistic that cannot exist and give it a p-value that means something else. That is what one paper in the queue did: it reported Spearman rho = 0.94, p = 0.017 over five assets. On five untied ranks, rho lives on a finite grid spaced exactly 0.1 apart. The smallest two-sided p the test can produce is 0.0167, and 0.017 is the exact p-value of a perfect ranking. The nearest attainable rho, 0.90, carries p = 0.0833 — not significant at 5%. The claim is not subtly wrong; it is printed arithmetic that could not have come from the test the paper claims to have run.

The system that caught it is not another return-predicting model. It is an auditor: a loop over a local corpus of 21,305 quant-finance paper abstracts, with 21,119 still queued, 29 papers read end to end by a human, and 82 machine screens completed. Each tick claims one paper, asks a language model two questions about it, runs deterministic nulls against real market data, and records a verdict under a schema that refuses records which certify themselves. The most important thing I can tell you about this loop is not that it found fake alpha. It is that its ceiling is the corpus, not the model — and that honesty about that ceiling is the actual product.

Your model says buy. Your risk engine says no. Who wins?

In most trading stacks the honest answer is "whoever is louder." A Python notebook model outshouts a config-file risk limit by default. But there is a sharper question hiding behind that one, and it changes the outcome: what happens when the model is wrong, and the architecture is built so it cannot hide?

This is the story of a two-plane algorithmic trading stack in Rust — four crates, 388 tests, zero failures — where an ML model fitted with Hugging Face's candle was given every chance to earn its place, and then lost to a momentum factor on out-of-sample data. The model did not fail because someone judged it unworthy. It failed because it could not show a number, and the thing that checked the number lived in a different process and a different dependency graph.

That is the design. Everything else in this build follows from it.

An optimistic backtest can show Sharpe 5 where live reality is negative, and an AI-first crypto trading system graded by it will optimise into the gap with total conviction — because inside that simulator the strategy genuinely works.

The simulator is not a test. It is the model's reward function. That is the sharpest trap I know, and the rest of this post is what I found while walking into it.

Here is the shape of what I found. Give a router a third action — quote, cross, or abstain — and it takes the third. Doing nothing scores zero; every alternative scores less; and zero wins 11 of 11 panels without the signal being consulted at all. The fitted policies that do trade pick about 1.6% of rows and still end below zero. A model that has learned to almost-not-play is not broken. It is reporting the absence of an edge — the one output no trade-count metric will ever reward.

Everything that decides whether such a system makes money on a perp lives in the coupling between model and market: fees, funding, regime, and the evidence you are willing to accept. A round trip costs 4–14 bps before the model says a word.

I went looking for that edge at sub-minute horizons and did not find it. What the search produced instead was thirty-nine principles about how to run a model against a market — each ending with the condition that breaks it, each carrying the measured number behind it, and several carrying the number that killed an earlier version of the same claim. They are worth more than the strategy would have been.

TL;DR Hyperliquid runs its own Layer-1 with two execution domains:

• HyperCore — native on-chain central limit order book (CLOB), margin, funding, liquidations.
• HyperEVM — standard EVM runtime (gas metered, paid in HYPE).

Trading on HyperCore is gasless: orders, cancels, TP/SL, TWAP, Scale ladders, etc. are signed actions included in consensus, not EVM transactions.

• You don’t need HYPE to place/cancel orders.
• You pay maker/taker fees and funding, not gas.
• Spam is mitigated with address budgets, rate limits, open-order caps.
• If you need more throughput: buy request weight at $0.0005 per action.

The design enables CEX-style strategies (dense ladders, queue dancing, rebates, hourly hedging) without the friction of gas.

Official GitHub repos:

• Python SDK → https://github.com/hyperliquid-dex/hyperliquid-python-sdk
• Rust SDK → https://github.com/hyperliquid-dex/hyperliquid-rust-sdk
• Node → https://github.com/hyperliquid-dex/node
• Order Book Server (example) → https://github.com/hyperliquid-dex/order_book_server

“The markets are never wrong; opinions often are.”
—Jesse Livermore (quoted by Bruce Kovner in Market Wizards)

Introduction​

Gradient Descent is a fundamental optimization algorithm used in machine learning and quantitative finance. In the context of algorithmic trading, it helps in optimizing predictive models, from price forecasting to portfolio optimization. Understanding how Gradient Descent works and how it can be applied in the financial markets is crucial for developing effective trading strategies.

In this article, we will explore the concept of Gradient Descent, its variations, and its applications in trading.

Introduction​

Euclidean distance is not just a mathematical concept but a crucial tool for data analysis in various fields, including trading and quantitative finance. In algorithmic trading, Euclidean distance can be applied to evaluate the similarity between financial assets, identify trading signals, and optimize portfolio allocation. As a distance metric, it helps in quantifying the relationship between different financial data points, allowing for more effective trading strategies.

In this article, we will discuss what Euclidean distance is, how it's calculated, and where it fits in the world of financial markets and algorithmic trading.

Introduction​

The advent of AI in trading has dramatically transformed the landscape of financial market analysis and execution. AI-driven strategies enable traders to process vast amounts of data, identify patterns, and execute trades with a level of precision and speed that was previously unattainable. By leveraging machine learning algorithms, traders can now develop adaptive models that adjust to market conditions in real-time, providing a competitive edge in the fast-paced world of trading.