BTC response field, read against SPY down-events and the Hawkes excitation curve. Red bars are not bear candles here. They are marked arrivals.
Alan G. Hawkes published the process that carries his name in 1971. The construction is a point process whose arrivals are not independent: every arrival raises the intensity of future arrivals, then fades. It became the language of aftershocks, neuron firing, defaults, order-book cascades, and every market situation where one event makes the next event more likely.
The boring question is whether bitcoin is correlated with equities. This page asks the sharper one: does the equity tape excite bitcoin? A green stock candle expands risk appetite. A red stock candle releases stress, hedging demand, margin movement, and attention escape. The sign changes. The event remains fuel.
A symmetric model uses one coefficient for every equity move. This instrument refuses that. Positive SPY events enter with alphaUp. Negative SPY events enter with alphaDown. The thesis is the inequality. Up is fuel. Down is louder fuel.
lambdaBTC(t) is not the bitcoin price. It is the current excitation intensity produced by the equity event stream. mu is the baseline. beta is the decay rate. Nspy+ counts positive equity events. Nspy- counts negative equity events. The two marks are alphaUp and alphaDown.
The page reads the last 256 one-minute candles for SPY and BTC-USD, splits SPY returns into positive and negative event streams, applies the asymmetric Hawkes kernel, and plots the result. No private database, no hidden oracle, no team server. Replace SPY with QQQ or NVDA and the same kernel still runs.
Correlation is a statement about co-movement after the fact. It flattens time. A Hawkes process keeps time inside the model. The question is not whether two series ended up pointing in the same direction. The question is whether an event in one series raised the intensity of a later response in the other. That is why the chart reads the equity tape as arrivals, not as a second price line.
The red candle is not treated as bearish for bitcoin. It is treated as an event with a larger mark. In ordinary finance language this sounds wrong. In event language it is clean: a forced move in the old venue creates more attention than a calm move. Red equity minutes carry liquidation risk, hedge demand, media attention, volatility targeting, dealer repositioning, and portfolio stress. Those are all arrivals.
A Hawkes event cannot be allowed to live forever. The kernel decays because markets metabolize shocks. A large equity event can raise bitcoin's excitation immediately, but if no confirming events arrive, the effect fades. This is the difference between a pulse and a regime. The page keeps memory short enough to behave like an instrument, not a mythology engine.
Bitcoin is the right response surface because it trades through the hours when the equity venue stops speaking. It is liquid enough to absorb macro flow, old enough to carry the risk-off story, and strange enough to become the risk-on exit at the same time. The model does not need bitcoin to be a hedge. It only needs bitcoin to be the market that remains awake when the old market produces a shock.
A high lambda does not mean bitcoin must go up on the next candle. It means the equity tape is currently producing a dense cluster of events that this model marks as bitcoin-exciting. If price fails to respond while lambda stays high, that failure is itself information. The instrument is a pressure gauge, not a prophecy.
The model can be wrong in public. If negative equity events repeatedly fail to produce stronger bitcoin response than positive equity events, the inequality is false for that window. The page does not hide that. It draws the intensity, the down-event bars, and the response field together so the claim can be visually attacked.
SPY is only the default old-market tape. It can be replaced by QQQ, NVDA, the VIX, a Treasury ETF, or a basket of index futures. BTC-USD is only the default response surface. It can be replaced by a direct exchange feed or a perpetual swap midprice. The object is not the data vendor. The object is the asymmetric excitation rule.
$HAWKES is not presented as the cause of bitcoin's move. That would be fake. Its role is stranger: it is the public handle for the measurement. The market can trade the thesis itself. If the page says the old market is exciting bitcoin, the token becomes the thing people use to say they saw the excitation.
Once the token exists, its swaps become a third event stream. SPY supplies the shock. BTC supplies the response surface. $HAWKES supplies the attention tape. A buy is not just a buy; it is an arrival saying that the asymmetric rule has entered someone's head. A sell is also an arrival. The token turns belief in the model into observable order flow.
The clean version of the system has two layers. Layer one computes lambdaBTC from equity events. Layer two computes lambdaHAWKES from lambdaBTC and the token's own event stream. When equities fall and bitcoin excitation rises, attention can migrate into the token that names the effect. The token does not need to control the model. It becomes the market's response to seeing the model.
The honest claim is not that $HAWKES must go up when stocks fall. The honest claim is that $HAWKES is designed to be the tradable cultural surface of that thesis. If people believe the asymmetric excitation is real, their trades create a visible third tape. If they do not, the tape stays quiet. The token's importance is therefore falsifiable, not promised.
00:00:00 / kernel armed
00:00:00 / waiting for public candles
the source · open-source kernel
A zero-backend event instrument. Reads 256 one-minute public candles, splits the equity tape into positive and negative event streams, applies unequal marks, decays the memory, and exposes both bitcoin excitation and token attention intensity. The code below is the complete kernel shape.
// app/hawkes/kernel.ts
// hawkes — asymmetric bitcoin excitation instrument
// stocks up: bitcoin rises.
// stocks down: bitcoin receives the larger excitation.
// the token is the public attention tape of the thesis.
export const WINDOW = 256;
type Candle = {
time: number;
close: number;
volume: number;
};
type HawkesPoint = {
minute: string;
spyReturn: number;
btcReturn: number;
btcField: number;
excitation: number;
asymmetry: number;
};
const MU = 0.18; // baseline bitcoin excitation
const NU = 0.04; // baseline token attention
const DECAY = 0.91; // event memory decay
const ALPHA_UP = 0.85; // green equity mark
const ALPHA_DOWN = 1.90; // red equity mark; must exceed alphaUp
const BTC_RESPONSE = 6.0; // transfer from lambdaBTC to response field
const TOKEN_RHO = 0.72; // transfer from lambdaBTC to token attention
const TOKEN_ETA = 0.40; // self-attention mark from token swaps
function clamp(value: number, min: number, max: number) {
return Math.min(max, Math.max(min, value));
}
function returns(candles: Candle[]) {
return candles.map((candle, index) => {
if (index === 0) return 0;
const previous = candles[index - 1];
return ((candle.close - previous.close) / previous.close) * 100;
});
}
export function hawkesStep(params: {
lambdaBTC: number;
lambdaHAWKES: number;
spyReturn: number;
btcReturn: number;
hawkesSwapArrivals: number;
}) {
const up = Math.max(params.spyReturn, 0);
const down = Math.max(-params.spyReturn, 0);
const shock = ALPHA_UP * up + ALPHA_DOWN * down;
const lambdaBTC = clamp(params.lambdaBTC * DECAY + shock, 0, 8);
const btcField = clamp(50 + params.btcReturn * 12 + lambdaBTC * BTC_RESPONSE, 0, 120);
const lambdaHAWKES = clamp(
NU + TOKEN_RHO * lambdaBTC + TOKEN_ETA * params.hawkesSwapArrivals,
0,
12,
);
const asymmetry = clamp((down * ALPHA_DOWN - up * ALPHA_UP + lambdaBTC) * 18, 0, 100);
return { lambdaBTC, lambdaHAWKES, btcField, asymmetry };
}
export function buildSeries(spyCandles: Candle[], btcCandles: Candle[]): HawkesPoint[] {
const spyWindow = spyCandles.slice(-WINDOW);
const btcWindow = btcCandles.slice(-WINDOW);
const spyReturns = returns(spyWindow);
const btcReturns = returns(btcWindow);
let lambdaBTC = MU;
let lambdaHAWKES = NU;
return spyWindow.map((candle, index) => {
const step = hawkesStep({
lambdaBTC,
lambdaHAWKES,
spyReturn: spyReturns[index],
btcReturn: btcReturns[index],
hawkesSwapArrivals: 0,
});
lambdaBTC = step.lambdaBTC;
lambdaHAWKES = step.lambdaHAWKES;
return {
minute: new Date(candle.time).toLocaleTimeString("en-US", {
hour12: false,
hour: "2-digit",
minute: "2-digit",
}),
spyReturn: Number(spyReturns[index].toFixed(4)),
btcReturn: Number(btcReturns[index].toFixed(4)),
btcField: Number(step.btcField.toFixed(3)),
excitation: Number(lambdaBTC.toFixed(3)),
asymmetry: Number(step.asymmetry.toFixed(3)),
};
});
}
// invariant:
// alphaDown > alphaUp > 0
// $HAWKES is not the cause of BTC movement.
// $HAWKES is the tradable attention layer attached to the public readout.