A Quadratic Turnover Penalty Is Not Hysteresis for a Regime Allocator
For a two-regime allocator with a one-day objective, a quadratic penalty on weight changes gives a smoother that trails every jump and a proportional cost gives a no-trade band. Only the band is hysteresis.
| Section | Sources cited | Equations | Code listings |
|---|---|---|---|
| 1. Two turnover controls that are not the same operator | 1, 5 | 0 | 0 |
| 2. Turnover of a blend of two regime portfolios | 3 | 1 | 0 |
| 3. A quadratic penalty yields partial adjustment | 4, 5 | 2 | 0 |
| 4. A proportional cost yields a no-trade band | 3, 6 | 1 | 0 |
| 5. Hysteresis means memory without a time scale | 2, 7, 8 | 1 | 0 |
| 6. A reproducible program in exact arithmetic | none | 0 | 1 |
| 7. Reading the output around the regime switch | none | 0 | 0 |
| 8. Assumptions and limitations of the band rule | 6 | 0 | 0 |
01 /Two turnover controls that are not the same operator
A regime allocator that turns a filtered stress probability into portfolio weights inherits every movement of the filter. A recent paper on regime detection states the gap: filtering does not by itself say when an agent should act. Because rebalancing may be costly, it adds, acting continuously on filtered regime probabilities is generally not optimal [1]. A study of regime-switching signals measures the symptom: with no averaging window, the regime it infers online from a hidden Markov model shifts 8.5 times per year on average in its sample from 1982 to 2023 [5].
Two remedies suggest themselves, a penalty on weight changes and a cost on trading. Both make the holding depend on its past and both reduce trading, so it is tempting to call either one hysteresis. This article shows that they are different operators. A quadratic penalty yields partial adjustment: the holding moves a fixed fraction of the way to the target at every update. It trades at every update while a gap remains, trails a jump by a fixed fraction of its size, and ends elsewhere when the same move arrives in more updates, even with its constant rescaled to the faster clock.
A proportional trading cost yields a no-trade band. The holding stays put while the target is within a fixed distance, never trails it by more than that distance, and ends in the same place however many updates a move arrived in. Only the band is hysteresis. A quadratic penalty that carries that label is a smoother: a causal exponential average of past targets, not the look-ahead smoothed probability of a regime model.
The setting is small: two regimes, three assets, one decision per day from the filtered probability alone. Two earlier articles on this site are used as given. The article of 13 October 2026 showed that the forward filter is causal while the smoothed probability is not, and the article of 15 October 2026 introduced the column-stochastic projection from regime probabilities to weights. One Python program in exact rational arithmetic produces every number of the example.
02 /Turnover of a blend of two regime portfolios
Let regime 0 be calm and regime 1 stress. The transition matrix is row-stochastic: entry is the probability of moving from regime to regime . The filtered stress probability comes from the forward recursion and uses observations up to day only. The matrix , with assets and regimes, is non-negative and column-stochastic. Its columns and are the calm and the stress portfolio, and the target weights are .
The allocator holds a blend of the same two portfolios, , with a held stress share between 0 and 1. Turnover is counted one way, as half the absolute change in weights, and for a blend it is proportional to the move in the held share. A recent paper on regime-aware investing uses the same one-way convention: it defines daily turnover as half the norm of the change in weights [3].
Both weight vectors are blends of the same two columns, so . Because each column sums to one, over the assets : one minus the overlap of the two portfolios.
The constant is the turnover of a complete move from the calm to the stress portfolio, and in the example . An allocator that follows the target, , turns over times the total variation of the filtered probability, so every flicker of the filter is traded at full size. Since , for two regimes this identity sharpens the bound given in the article of 15 October 2026, that the change in weights cannot exceed the change in probabilities.
03 /A quadratic penalty yields partial adjustment
Suppose the allocator minimizes each day a tracking loss plus a quadratic penalty on the change in weights, . Both coefficients price a squared distance between weight vectors in one unit of account, so only their ratio matters. On blends both distances are multiples of , with , and the only unknown is the held share.
Setting the derivative to zero gives the rule. Over all weight vectors the minimizer is , which is this same blend, so the restriction to blends costs nothing here.
Three properties follow. The holding changes at every update at which the target differs from it, however small the difference. The rule is linear: a path whose moves are half as large produces trades half as large. And each trade leaves a fixed fraction of the gap that preceded it, so a jump of size from rest leaves the allocator short of its target, whatever is.
The first relation is the rule rearranged. The second unrolls it from the initial holding : the holding is an exponentially weighted average of past targets, with weights that decay by the factor per update.
The second relation shows the kind of memory: a weighted average of past targets whose weights fade with the number of updates. The rule has a scale in time, about updates, and none in the size of a move. If the target jumps and stays, the trades add up to the whole jump in the limit: a one-way shift is postponed, not saved.
Continuous-time theory has the same structure. With linear price impact, whose trading costs are quadratic, a paper on small price impact finds that one always trades toward the frictionless target at a finite rate. The displacement from that target cannot be kept uniformly small [4].
The study of regime-switching signals cited at the start reports the delay of an averaging rule on the regime label. It signals the high-volatility regime when the rolling mean of the inferred labels over a trailing window exceeds one half. Widening the window, it finds, reduces the number of shifts, but not efficiently: a window of 20 days, which it equates with a signal latency of at least 10 days, still leaves about 2 shifts per year [5].
04 /A proportional cost yields a no-trade band
Now replace the quadratic penalty by a cost of per unit of one-way turnover, in the same unit of account as . By the turnover relation, moving the held share from to costs . Among blends the daily problem again has one unknown, and its solution is a clamp. The restriction to blends and the one-day horizon are both taken up in the last section.
Moving the held share costs per unit and reduces the tracking loss by per unit. Trading stops where the two are equal, at distance from the target; closer than that, no move pays.
While the target stays within of the holding, nothing is traded, so is the half-width of the band. When the target leaves that interval, the holding moves to the nearer edge of the band around the new target, short of it, and no further. For a holding that starts the day within of the previous target, three properties follow. The gap never exceeds . A trade is never larger than the day's move of the target. And after the held share has been raised it sits at the lower edge of the band, so the target can fall back by up to before the share is lowered.
A primer on portfolio choice with small transaction costs states the continuous-time counterpart. With proportional costs the investor does only the minimal amount of trading that keeps the position inside a no-trade interval around the frictionless target [6]. A proportional term also appears in the regime-aware study cited above: it subtracts a multiple of from its mean-variance objective [3].
05 /Hysteresis means memory without a time scale
In the mathematics of hysteresis the band rule is the play operator. A paper on conservation laws with hysteresis describes it for an input , an output, written here, and an amplitude . The pair stays in the strip ; the output does not change inside the strip, and on a boundary it moves together with an input that pushes outward. The output depends on the whole history of the input. This memory is rate-independent: it does not depend on the speed of the input. The paper calls that the main characterization of hysteresis phenomena [7].
With , and this is the rule of the previous section, and its rate independence has an elementary discrete form. Write for one step of the band. Let the holding be within of the previous target , and insert a value between and the new target as an extra update. Two steps then give the same holding as one.
is the previous target and the new one. For a rising target both sides equal , because the upper edge of the band never binds; a falling target is symmetric.
Partial adjustment has no such property. With the same inserted value its two-step holding differs from its one-step holding by , which vanishes only when . Its parameter is tied to the clock: an allocator that updates twice as often with the same is a faster smoother. Rescaling the constant does not repair this. A single update with the constant equals two updates with toward an unchanged target. When the move arrives through , the two-step holding differs from that single update by , zero only when . The band, at a fixed , has the opposite profile: a scale in the size of a move, , and none in time.
The same kind of memory is used one level up, on the regime label. A study of sector rotation, in what it calls a confidence threshold rule, replaces the label only when a posterior probability reaches 0.65 and otherwise keeps the previous one [2]. A hysteretic GARCH model uses the word itself: it keeps the previous value of its regime indicator inside what it calls a hysteresis zone [8].
In the setting of this article, a rule on the label would switch between the two regime portfolios at a boundary. The band moves the held share only by the amount by which the target has left it.
06 /A reproducible program in exact arithmetic
The program runs a two-regime hidden Markov model on 24 days of a three-valued observation, the size class of the day's move: small, medium or large. A large move has probability 0.10 in calm and 0.50 in stress. The chain stays calm with probability 0.95 and in stress with probability 0.90, and the prior stress probability is one third. The calm portfolio is , the stress portfolio . All inputs are invented. The observations were written by hand, not simulated: a quiet stretch with one isolated large move, called the false alarm below, then a stretch of mostly large moves, called the regime switch, and a return to quiet.
The dials are , and , which give and . The value of was chosen so that the two rules turn over similar amounts on this path. Three allocators start from the first day's target and follow it, smooth it, or apply the band. A fourth run doubles the half-width. Two further paths test the operators: the targets with the midpoint of every daily move inserted, and the targets shrunk to one sixth of their distance from the first value. On the path with midpoints the smoother makes two updates per day. It is compared with a matched daily smoother, whose constant makes one update equal to two toward an unchanged target.
Every quantity is an exact rational number, so the assertions are equalities and inequalities without a tolerance, and nothing is drawn at random. Printed values are rounded to four decimals. The filter is the forward recursion, and no smoothed probability appears. The first assertion checks that rows of the transition and emission tables and columns of sum to one. The others test the following statements and nothing more.
- On each of the first eight days the forward recursion equals the posterior from enumerating every regime path, and a held share of one gives the stress column of .
- Following the target turns over exactly times the total variation of , and the 24-day totals rise from wide band to smoother to band to follow.
- Under its own objective, each step of the smoother and of the band costs no more than that step moved by one millionth either way.
- With midpoints inserted, the band's holdings on the original days are unchanged. On the shrunk path the smoother turns over exactly one sixth as much.
- On day 2 the two-update smoother's holding minus the matched daily smoother's equals , with the inserted midpoint and the day's target, and is not zero.
- The band makes no trade on the shrunk path and at least one on the original path, on fewer days than the smoother, which trades on all 23.
- The band's largest gap equals and the wide band's equals ; the smoother's largest gap is larger than and is its shortfall on day 15.
# Synthetic unit-check fixture; illustrative only, no live market data or performance claims.
from fractions import Fraction as F
import itertools
import math
table = lambda rows: [[F(v, 20) for v in row] for row in rows]
trans = table([[19, 1], [2, 18]]) # trans[i][j] = P(j next | i); regime 1 is stress
emit = table([[13, 5, 2], [5, 5, 10]]) # emit[regime][symbol]; symbol 2 is a large move
proj = table([[12, 3], [6, 7], [2, 10]]) # N x K; column k = regime k
start = [F(2, 3), F(1, 3)] # prior on day 1
obs = [0, 0, 1, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 2, 2, 1, 2, 2, 0, 0, 0, 1, 0, 0]
kappa, cost, gam = 2, F(6, 25), 6 # tracking weight, turnover cost, quadratic penalty
dist, quad = sum(abs(b - a) for a, b in proj) / 2, sum((b - a) ** 2 for a, b in proj)
band, alpha = cost * dist / (kappa * quad), F(kappa, kappa + gam)
def hamilton(ys): # forward recursion: P(stress at t | y_1..y_t)
prior, path = start, []
for y in ys:
joint = [prior[s] * emit[s][y] for s in (0, 1)]
path.append(joint[1] / sum(joint))
prior = [sum(joint[i] * trans[i][s] for i in (0, 1)) / sum(joint) for s in (0, 1)]
return path
def brute(ys): # the same at the last date, by enumeration
mass = [0, 0]
for path in itertools.product((0, 1), repeat=len(ys)):
like = math.prod(emit[s][y] for s, y in zip(path, ys)) * start[path[0]]
mass[path[-1]] += like * math.prod(trans[a][b] for a, b in zip(path, path[1:]))
return mass[1] / sum(mass)
run = lambda rule, path, *arg: list(itertools.accumulate(path, lambda q, p: rule(q, p, *arg)))
smooth = lambda q, p, a=alpha: q + a * (p - q) # quadratic penalty
play = lambda q, p, half=band: min(max(q, p - half), p + half) # proportional cost
mix = lambda xs: [a * (1 - x) + b * x for x in xs for a, b in proj] # proj @ (1 - x, x)
turnover = lambda xs: sum(abs(a - b) for a, b in zip(mix(xs), mix(xs[1:]))) / 2 # one-way
loss = lambda x, p, q, g, c: quad * (kappa * (x - p) ** 2 + g * (x - q) ** 2) / 2 + c * abs(x - q)
trades = lambda xs: sum(u != v for u, v in zip(xs, xs[1:]))
gap = lambda xs, ys: max(abs(x - y) for x, y in zip(xs, ys))
p_f = hamilton(obs)
x_s, x_p, x_w = run(smooth, p_f), run(play, p_f), run(play, p_f, 2 * band)
fine = [p_f[0]] + [v for a, b in zip(p_f, p_f[1:]) for v in ((a + b) / 2, b)] # midpoints added
x_f, x_m = run(smooth, fine)[::2], run(smooth, p_f, 1 - (1 - alpha) ** 2) # finer clock, matched
small = [p_f[0] + (p - p_f[0]) / 6 for p in p_f]
t_f, t_s, t_p, t_w = (turnover(xs) for xs in (p_f, x_s, x_p, x_w))
assert all(sum(r) == 1 for r in trans + emit + list(zip(*proj)))
assert all(p_f[t] == brute(obs[:t + 1]) for t in range(8)) and mix([1]) == [b for a, b in proj]
assert t_f == dist * sum(abs(b - a) for a, b in zip(p_f, p_f[1:])) and t_w < t_s < t_p < t_f
for xs, g, c in ((x_s, gam, 0), (x_p, 0, cost * dist)):
assert all(loss(x, p, q, g, c) <= loss(x + F(e, 10 ** 6), p, q, g, c)
for x, p, q in zip(xs[1:], p_f[1:], xs) for e in (1, -1))
assert run(play, fine)[::2] == x_p and 6 * turnover(run(smooth, small)) == t_s
assert 0 != x_f[1] - x_m[1] == alpha * (1 - alpha) * (fine[1] - p_f[1])
assert trades(run(play, small)) == 0 < trades(x_p) < trades(x_s) == len(obs) - 1
assert gap(x_p, p_f) == band == gap(x_w, p_f) / 2 < p_f[14] - x_s[14] == gap(x_s, p_f)
show = lambda xs: ", ".join(f"{float(x):.4f}" for x in xs)
print(f"RESULT distance_and_half_width = [{show([dist, band])}]")
print(f"RESULT turnover_follow_smooth_play_wide = [{show([t_f, t_s, t_p, t_w])}]")
print(f"RESULT turnover_first_12_days = [{show(turnover(xs[:12]) for xs in (p_f, x_s, x_p))}]")
print(f"RESULT trade_days_follow_smooth_play = {[trades(p_f), trades(x_s), trades(x_p)]}")
print(f"RESULT max_gap_smooth_play = [{show([gap(x_s, p_f), gap(x_p, p_f)])}]")
print(f"RESULT resample_shift_matched = {float(gap(x_f, x_m)):.4f}")
for name, xs in (("target", p_f), ("held_smooth", x_s), ("held_play", x_p)):
print(f"SERIES {name} = [{show(xs)}]")
print("OK")CAPTURED OUTPUT10 LINES · 8 ASSERT STATEMENTS, 9 EVALUATIONS PASSED · RUN NOV 14, 2026 · SHA-256 4efa9112e76a…
RESULT distance_and_half_width = [0.4500, 0.1479] RESULT turnover_follow_smooth_play_wide = [1.3386, 0.5545, 0.5833, 0.3686] RESULT turnover_first_12_days = [0.4247, 0.0860, 0.0287] RESULT trade_days_follow_smooth_play = [23, 23, 10] RESULT max_gap_smooth_play = [0.4561, 0.1479] RESULT resample_shift_matched = 0.0488 SERIES target = [0.1613, 0.0813, 0.1191, 0.0641, 0.1045, 0.0584, 0.3562, 0.1733, 0.0864, 0.1234, 0.0659, 0.0436, 0.3229, 0.7060, 0.9028, 0.8174, 0.9359, 0.9647, 0.7202, 0.4299, 0.2146, 0.2324, 0.1123, 0.0615] SERIES held_smooth = [0.1613, 0.1413, 0.1358, 0.1179, 0.1145, 0.1005, 0.1644, 0.1666, 0.1466, 0.1408, 0.1221, 0.1024, 0.1576, 0.2947, 0.4467, 0.5394, 0.6385, 0.7201, 0.7201, 0.6475, 0.5393, 0.4626, 0.3750, 0.2966] SERIES held_play = [0.1613, 0.1613, 0.1613, 0.1613, 0.1613, 0.1613, 0.2083, 0.2083, 0.2083, 0.2083, 0.2083, 0.1916, 0.1916, 0.5581, 0.7549, 0.7549, 0.7879, 0.8168, 0.8168, 0.5778, 0.3626, 0.3626, 0.2603, 0.2094] OK
Standard output of the program above, captured when it was run in the journal's sandbox on Nov 14, 2026. The SHA-256 of the program text shown here equals the hash stored with that run. All inputs are synthetic.
07 /Reading the output around the regime switch
For twelve days the filtered probability stays between 0.0436 and 0.1733, except for the false alarm on day 7, when a single large move lifts it from 0.0584 to 0.3562. Three large moves on days 13 to 15 carry it to 0.3229, 0.7060 and 0.9028. It peaks at 0.9647 on day 18 and is back at 0.2146 by day 21.
Following the target turns over 1.3386 in total, of which 0.4247 falls in the first twelve days. The smoother spends 0.0860 over the same stretch, trading at every update. The band spends 0.0287 on two days. On day 7 it lifts the held share from 0.1613 to 0.2083, the part of the false alarm beyond the band, and on day 12 it lowers it to 0.1916.
The switch separates the rules. On day 13 the target, at 0.3229, is still inside the band around 0.1916, and the band does nothing. On day 14 the target is 0.7060: the band jumps to 0.5581, exactly below it, while the smoother holds 0.2947. On day 15, with the target at 0.9028, the smoother holds 0.4467. Its gap of 0.4561 is the largest of the path, about three times the half-width, on the day the stress probability first exceeds 0.9.
This is the fixed-fraction property. With the smoother keeps three quarters of any gap that opens, so its shortfall grows with the move, while the band's is capped at . The gap of 0.4561 and its ratio to belong to this path and these dials; the proportionality and the cap do not. The band pays for the cap: it never closes the last . On day 18 it holds 0.8168 against a target of 0.9647, and it would stay that far from a target that stopped moving, where the smoother would converge.
Turnover does not rank the rules. Over the 24 days the band turns over 0.5833 on 10 trading days and the smoother 0.5545 on 23; the smoother's trade on day 19 is smaller than the printed precision. But the path ends with the target at 0.0615, the band at 0.2094, a distance from it, and the smoother at 0.2966. If the target stayed there, the band would not trade again and the smoother would, so the smoother's 24-day total understates its trading. With the half-width doubled the band's total falls to 0.3686. The dials and the path decide which rule trades less, not the type of rule.
The two operator tests show the same split. With midpoints inserted and the same , the band ends each original day at exactly the same holding, as the two-step identity requires. The smoother with two updates per day differs from the matched daily smoother by as much as 0.0488 at the end of a day. On the shrunk path the smoother turns over exactly one sixth as much, as linearity requires. The band makes no trade there: the whole shrunk path lies within of the first holding.
08 /Assumptions and limitations of the band rule
The band rule was derived for holdings that are blends of the two regime portfolios, and it is the exact daily minimizer only there. Over all weight vectors the proportional cost charges each asset separately, and the minimizer need not stay on the segment between the two portfolios. An asset whose calm and stress weights are nearly equal gains little from trading and can be left out of the trade. The program does not compute that case.
With more than two regimes the triangle inequality gives a bound in place of the identity: turnover is at most times half the change of the probability vector, with now the largest such distance between two columns of . The held vector then has more than one free coordinate, the one-dimensional clamp no longer applies, and this article gives no closed form for the band.
The half-width formula comes from a one-day objective. It sets one day of tracking loss against a cost paid once, although a trade keeps reducing the tracking loss for as long as the regime lasts. The coefficient is therefore a dial tied to the decision interval, and is better treated as the design parameter. The dynamic problem scales differently. For the continuous-time model that the primer reviews, the scaling argument it presents puts the width of the optimal no-trade region at the order of the cube root of a small proportional cost [6].
In this article is linear in , so the daily rule does not reproduce that scaling and should not be read as the dynamic optimum. Rate independence is a property of the operator at a fixed . The program tests it by inserting values between daily targets; a filter run on finer data would produce a different path, not an interpolation.
Weights drift with returns between decisions, so the holding before a trade is not exactly a blend. The cost is the same in both regimes, and the parameters of the chain are given, not estimated. The numbers show how two rules differ as operators on one synthetic path. They are not evidence about returns, costs saved or any tradable strategy.
Research is complete only when the assumptions, experiment, and limitations can be reconstructed.
This perspective is research commentary. It does not constitute investment advice or evidence of live strategy performance. Experimental methods require project-specific testing. Equations and code illustrate research formulations, not measured live returns.