Mathematics of Large Numbers: From a Zero-Sum Game to a Growing-Sum Game

The source code analyzed in the article is published in this repository.

One might assume this is related to information leakage, with other market participants using the strategy and siphoning off liquidity. But the real reason is different: this is the fundamental law of large numbers. Market volume is predictable, meaning it is a finite sum. When playing a finite-sum game, the total capital in the market is constant and only migrates between participants: your profit is someone else's loss.

Look at the chart: portfolio income growth rises at first, then hits a plateau with no clear upward or downward movement. The closest analogy is an object thrown upward: when the forces of acceleration and gravity are balanced, it stops at a certain point, then falls back down.

Finite-sum game

Any effective quant strategy exploits market inefficiency. As soon as everyone starts using the exploit, the inefficiency disappears, because it was created precisely by the fact that no one was arbitraging it. The market reaches equilibrium. And for participants, equilibrium means one simple thing: the expected value of a trade becomes zero minus the exchange commission. Not "small profit", but a strictly negative number.

Escape to the growing-sum game

There is only one way out of this trap: focus on things that bring new money into the system rather than redistributing the money that is already there. You might think this refers to company or fund accounting reports, but no: publishing financial statements does not guarantee deterministic behavior from market participants. Mathematically, a guarantee of a growing game sum is a direct public offering, if its size tends towards infinity.

Riding to paradise on someone else's back

Earlier I broke down the stop hunting liquidity-gathering pattern: market participants publish a post with panic sentiment to trigger a mass sell-off, as a result the asset can be bought back all at once at a lower price. But you can also profit just as well from euphoria.

The Telegram channel publishes trading signals, which are successful in 68% of cases. A regular retail investor won't look any further. But this is a trap: risk management does not protect at all against black swan scenarios.

Risks:

1. High volatility relative to average profit

   The average trade nets +2.37%, but the standard deviation is ±7.86%. One or two large losses easily eat up the profit from a dozen small wins, while the winrate remains "impressive".

2. Low Sharpe = weak risk compensation

   A Sharpe of 0.3 indicates that profit is not large enough relative to the risk taken. Good trading aims for a Sharpe > 1.0.

This is another pattern for leveraging crowd liquidity: pump and dump. Let's test the hypothesis by selecting only those signals where the asset's price has already risen over the previous N hours.

What improved:

1. Sharpe Ratio increased 2.67 times (0.302 → 0.807)

   Now profit compensates for the taken risk much better.

2. Average trade profit increased almost 3 times (+2.37% → +6.97%)

   Portfolio drawdowns are eliminated: there are fewer losing trades.

The price increase over the past N hours is an empirical criterion. I knew where to look in advance, but I did not analyze the matrix of recommendation-type posts. If you take the top 100 channels, using the publication time and direction of the recommendation, you can identify a single author behind multiple anonymous accounts. Next, by linking to a single author, you can find out how many more channels they are potentially able to use to continue the pump

How to make money from this

Using self enforcement runtime, a parser and high-performance backtest, you can automatically update empirical entry criteria. The channel parser extracts the direction, entry zone, targets and stop loss from the text using simple regex rules:

const SIGNAL_FORMAT: ParseFormat = {
    symbol: {
        pattern: /#([A-Z0-9]+)\/USDT/,
        group: 1,
    },
    direction: {
        pattern: /(SHORT|LONG)/i,
        transform: (raw) => (raw.toUpperCase() === "SHORT" ? "short" : "long"),
    },
    entry: {
        pattern: /zone\s+\$?([\d.,]+)\s*[-–—]\s*(?:\$?[\d.,]+\s*[-–—]\s*)?\$?([\d.,]+)(?=\s)/i,
        transform: (_, m) => ({ from: num(m[1]), to: num(m[2]) }),
    },
    targets: {
        pattern: /Close(?:\s+order)?\s+at(?:\s+price)?\s+\$?([\d.,]+)/gi,
        transform: (_, m) => num(m[1]),
        multi: true,
    },
    stoploss: {
        pattern: /STOP-?LOSS:\s*\$?([\d.,]+)/i,
        transform: (_, m) => num(m[1]),
    },
};

The high-performance backtest calculates metrics based on pre-publication data

const PRE_CANDLES_LIMIT = 1440; // 24h of 1m candles for baseline

// the getCandles(.., 1440) window covers exactly 24 hours BEFORE the signal is published
const preCandles = await getCandles(symbol, "1m", PRE_CANDLES_LIMIT);

// momentum24h — total price change over 24 hours before publication.
// Positive = the pump is already underway; negative = the market is falling.
const momentum24hPct =
  ((preCandles[preCandles.length - 1].close - preCandles[0].open) /
    preCandles[0].open) * 100;

Logger.log("pre-publication data", { momentum24hPct })

The AI agent programs the filters, updating them as code with each refresh.

const SHORT_MIN_AVG_RANGE_PCT = 0.07;
const LONG_MIN_MOMENTUM_24H_PCT = -1;

// Filter 1: SHORT on a "dormant" asset (avgRange < 0.07% per day, like TRX) —
// thin liquidity, an ideal target for stop-hunt. This is a case of liquidity
// harvesting: you cannot follow the signal.
if (signal.direction === "short" && avgRangePct < SHORT_MIN_AVG_RANGE_PCT) {
  return null;
}

// Filter 2: LONG when the price has dropped more than 1% in a day — "catching a falling knife".
// There is no capital inflow, there is a decline; subscribers are led against the trend.
if (signal.direction === "long" && momentum24hPct < LONG_MIN_MOMENTUM_24H_PCT) {
  return null;
}

Filter 1 catches the liquidity harvesting scam mode (zero inflow, stop manipulation) and says "do not enter". Filter 2 catches the absence of fundamental inflow (the market is falling, there is no pump at all) and also says "do not enter". Exactly what the whole setup was intended for remains: signals under which real capital inflow.

Conclusion

Pump via Telegram is not a market bug that gets arbitraged away and disappears. This is crowd behavior that reproduces every time the author has an audience. As long as there are subscribers, there is inflow. And that means there is a fundamental factor to which equilibrium arithmetic does not apply: this is a game with a growing sum.