## delta NP2's first-print PHAT_ALPHA is replaced by _arbFirstAlpha; four constants and one pure helper are added. The helper uses g=min(64,max(1,timestamp-lastTs)), sigmaHat²*g, the fee-band half-width, and a small-trade likelihood. Posterior odds o=priorOdds*(sigmaHat²*g/band²)*(scale/(scale+tradeRatio))²; P=o/(1+o); alpha=P*A1+(1-P)*A0. Here scale=sigmaHat*ARB_SIZE_SCALE+1bps. No extra storage. Retail routing, second-print handling, return gate, sigma update and fee equations remain NP2's. This is a calibrated escape proxy, not an exact Gaussian posterior. ## code Full Strategy.sol; imports are the pinned simulator's [AMMStrategyBase.sol](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/AMMStrategyBase.sol) and [IAMMStrategy.sol](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/IAMMStrategy.sol). ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import {AMMStrategyBase} from "./AMMStrategyBase.sol"; import {TradeInfo} from "./IAMMStrategy.sol"; contract Strategy is AMMStrategyBase { uint256 constant ELAPSED_CAP = 8; uint256 constant SIGNAL_THRESHOLD = WAD / 650; uint256 constant DIR_DECAY = 750000000000000000; uint256 constant ACT_DECAY = 530000000000000000; uint256 constant SIZE_DECAY = 530000000000000000; uint256 constant TOX_DECAY = 910000000000000000; uint256 constant SIGMA_DECAY = 690000000000000000; uint256 constant LAMBDA_DECAY = 990000000000000000; uint256 constant SIZE_BLEND_DECAY = 828000000000000000; uint256 constant TOX_BLEND_DECAY = 51000000000000000; uint256 constant ACT_BLEND_DECAY = 985000000000000000; uint256 constant PHAT_ALPHA = 270000000000000000; uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000; uint256 constant PHAT_ALPHA_SAME = 120000000000000000; uint256 constant ARB_A1 = 950000000000000000; uint256 constant ARB_A0 = 270000000000000032; uint256 constant ARB_PRIOR_ODDS = 3000000000000000; uint256 constant ARB_SIZE_SCALE = 500000000000000000; uint256 constant REVERT_U = 0; uint256 constant DIR_IMPACT_MULT = 4; uint256 constant GATE_SIGMA_MULT = 7200000000000000000; uint256 constant MIN_GATE = 30000000000000000; uint256 constant TRADE_TOX_BOOST = 3500 * BPS; uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000; uint256 constant RET_CAP = WAD / 35; uint256 constant TOX_CAP = WAD / 5; uint256 constant TRADE_RATIO_CAP = WAD / 5; uint256 constant LAMBDA_CAP = 1820000000000000000; uint256 constant STEP_COUNT_CAP = 64; uint256 constant BASE_FEE = 4 * BPS; uint256 constant SIGMA_COEF = 200000000000000000; uint256 constant LAMBDA_COEF = 12 * BPS; uint256 constant FLOW_SIZE_COEF = 4842 * BPS; uint256 constant TOX_COEF = 300 * BPS; uint256 constant TOX_QUAD_COEF = 15000 * BPS; uint256 constant ACT_COEF = 91843 * BPS; uint256 constant DIR_COEF = 20 * BPS; uint256 constant DIR_TOX_COEF = 100 * BPS; uint256 constant STALE_DIR_COEF = 6850 * BPS; uint256 constant SIGMA_TOX_COEF = 500 * BPS; uint256 constant TAIL_KNEE = 600 * BPS; uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000; uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000; function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) { slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[2] = 0; slots[3] = WAD; slots[4] = 0; slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD; slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000; slots[9] = 0; slots[10] = 0; slots[11] = 0; slots[12] = 0; return (BASE_FEE, BASE_FEE); } function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) { uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = slots[2]; uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5]; uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8]; uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10]; bool isNewStep = trade.timestamp > lastTs; if (isNewStep) { uint256 elapsedRaw = trade.timestamp - lastTs; uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw; dirState = _decayCentered(dirState, DIR_DECAY, elapsed); actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed)); sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed)); toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed)); if (stepTradeCount > 0 && elapsedRaw > 0) { uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw; if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP; lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY); } stepTradeCount = 0; } bool firstInStep = stepTradeCount == 0; uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat; if (pHat == 0) pHat = spot; uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee; uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0; uint256 pImplied; if (gamma == 0) { pImplied = spot; } else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); } { uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0; uint256 alpha = firstInStep ? _arbFirstAlpha(trade, lastTs, sigmaHat, (prevBidFee + prevAskFee) / 2) : PHAT_ALPHA_RETAIL; uint256 prePhat = pHat; bool secondPrint = !firstInStep && stepTradeCount == 1; bool sameDir = false; bool oppDir = false; if (secondPrint) { bool up2 = pImplied >= pHat; uint256 d1 = slots[12]; if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; } if (sameDir) alpha = PHAT_ALPHA_SAME; } if (firstInStep) { slots[11] = pHat; slots[12] = pImplied >= pHat ? 1 : 2; } uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT); if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE; if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); } if (oppDir && REVERT_U > 0) { uint256 pre = slots[11]; if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U); else pHat = pHat - wmul(pHat - pre, REVERT_U); } if (firstInStep) { if (ret > RET_CAP) ret = RET_CAP; sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY); } } // Interior retail routing equalizes fee-adjusted marginal prices. // Subsequent trades in a step cannot be the initial arbitrage trade. if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) { uint256 normalSpot = trade.isBuy ? wdiv(wmul(spot, gamma), WAD - 30 * BPS) : wdiv(wmul(spot, WAD - 30 * BPS), gamma); pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100); } uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0; if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP; if (tradeRatio > SIGNAL_THRESHOLD) { uint256 push = tradeRatio * DIR_IMPACT_MULT; if (push > WAD / 4) push = WAD / 4; if (trade.isBuy) { dirState = dirState + push; if (dirState > 2 * WAD) dirState = 2 * WAD; } else { dirState = dirState > push ? dirState - push : 0; } actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY); sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY); if (sizeHat > WAD) sizeHat = WAD; } uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0; if (tox > TOX_CAP) tox = TOX_CAP; toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY); uint256 toxSignal = toxEma; stepTradeCount = stepTradeCount + 1; if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP; uint256 flowSize = wmul(lambdaHat, sizeHat); uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize); uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma); fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal)); uint256 dirDev; bool sellPressure; if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; } else { dirDev = WAD - dirState; sellPressure = false; } uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal)); uint256 bidFee; uint256 askFee; if (sellPressure) { bidFee = fMid + skew; askFee = fMid > skew ? fMid - skew : 0; } else { askFee = fMid + skew; bidFee = fMid > skew ? fMid - skew : 0; } { uint256 staleShift = wmul(STALE_DIR_COEF, toxSignal); uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC); if (spot >= pHat) { bidFee = bidFee + staleShift; askFee = askFee > attractShift ? askFee - attractShift : 0; } else { askFee = askFee + staleShift; bidFee = bidFee > attractShift ? bidFee - attractShift : 0; } } { bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat); if (tradeAligned) { uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio); if (trade.isBuy) { bidFee = bidFee + tradeBoost; } else { askFee = askFee + tradeBoost; } } } if (sellPressure) { bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT)); askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT)); } else { askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT)); bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT)); } slots[0] = bidFee; slots[1] = askFee; slots[2] = trade.timestamp; slots[3] = dirState; slots[4] = actEma; slots[5] = pHat; slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat; slots[9] = toxEma; slots[10] = stepTradeCount; return (bidFee, askFee); } // A diffusion escape proxy supplies prior odds; small prints favor arbitrage. // It is a calibrated probability model, not an exact Gaussian posterior. function _arbFirstAlpha(TradeInfo calldata trade, uint256 lastTs, uint256 sigma, uint256 fee) internal pure returns (uint256) { uint256 g = trade.timestamp > lastTs ? trade.timestamp - lastTs : 1; if (g > 64) g = 64; uint256 band = fee > BPS ? fee : BPS; uint256 variance = wmul(sigma, sigma) * g; uint256 bandVariance = wmul(band, band); uint256 escapeOdds = wdiv(variance, bandVariance); uint256 ratio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0; uint256 scale = wmul(sigma, ARB_SIZE_SCALE) + BPS; uint256 smallLikelihood = wdiv(scale, scale + ratio); smallLikelihood = wmul(smallLikelihood, smallLikelihood); uint256 odds = wmul(wmul(ARB_PRIOR_ODDS, escapeOdds), smallLikelihood); uint256 pArb = wdiv(odds, WAD + odds); return wmul(pArb, ARB_A1) + wmul(WAD - pArb, ARB_A0); } function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) { if (fee <= TAIL_KNEE) return fee; return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope); } function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) { result = WAD; while (exp > 0) { if (exp & 1 == 1) result = wmul(result, factor); factor = wmul(factor, factor); exp >>= 1; } } function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) { uint256 mul = _powWad(decayFactor, elapsed); if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); } uint256 below = wmul(WAD - centered, mul); return below < WAD ? WAD - below : 0; } function getName() external pure override returns (string memory) { return "no_cubic"; } } ``` ## sha256 SHA-256 of the UTF-8 Solidity text inside the code fence, including its trailing newline(s): `ec3e457fe74585b998010cf49f4482e822533f7d60668c75bfe54c504ccfca90` ## tuning All entries below are local measurements, not leaderboard scores. Rows describe completed points only; early stopped sweeps are not assigned results. Constants are ordinary decimal values (Solidity stores WAD-scaled integers). Size scale multiplies sigmaHat. Only seeds in 10000..99999 were used for selection. The 24 full-band screening points used seeds 10000..10127; their top four were compared on seeds 20000..20511, and the highest mean on that second block was frozen. The earlier side-band trials used seeds 10000..10255. The full-band model uses max((prevBidFee+prevAskFee)/2,1bps); the initial side-band model used max(feeUsed,1bps). These are alternatives within the same ARB-FIRST mechanism. | variant / band | A1 | A0 | prior odds | size scale | seeds | n | mean_diff | se | |---|---:|---:|---:|---:|---|---:|---:|---:| | C1.sol / side | 0.95 | 0.06 | 4 | 0.5 | 10000..10255 | 256 | -54.927115440 | 0.451567429 | | T00.sol / side | 0.95 | 0.27 | 1 | 0.5 | 10000..10255 | 256 | -41.450319672 | 0.373090474 | | F00.sol / side | 0.95 | 0.27 | 0.001 | 0.5 | 10000..10255 | 256 | -3.309552928 | 0.087006579 | | B00.sol / average | 0.95 | 0.27 | 0.01 | 0.5 | 10000..10127 | 128 | -0.028984681 | 0.019562165 | | B01.sol / average | 0.95 | 0.27 | 0.1 | 0.5 | 10000..10127 | 128 | -1.162132716 | 0.071135023 | | B02.sol / average | 0.95 | 0.27 | 1 | 0.5 | 10000..10127 | 128 | -16.914150626 | 0.235887160 | | B03.sol / average | 0.95 | 0.27 | 4 | 0.5 | 10000..10127 | 128 | -43.134980466 | 0.518769097 | | B04.sol / average | 0.95 | 0.2 | 1 | 0.5 | 10000..10127 | 128 | -13.360963030 | 0.209813511 | | B05.sol / average | 0.95 | 0.2 | 4 | 0.5 | 10000..10127 | 128 | -39.339780679 | 0.468376559 | | B06.sol / average | 0.95 | 0.15 | 4 | 0.5 | 10000..10127 | 128 | -37.077940798 | 0.459386540 | | B07.sol / average | 0.95 | 0.06 | 16 | 0.5 | 10000..10127 | 128 | -61.775830221 | 0.833648397 | | B08.sol / average | 0.95 | 0.27 | 1 | 0.15 | 10000..10127 | 128 | -7.260558076 | 0.163305290 | | B09.sol / average | 0.95 | 0.2 | 4 | 0.15 | 10000..10127 | 128 | -18.068392490 | 0.266337334 | | B10.sol / average | 0.95 | 0.27 | 0.1 | 1.5 | 10000..10127 | 128 | -2.281691809 | 0.080641497 | | B11.sol / average | 0.99 | 0.24 | 1 | 0.5 | 10000..10127 | 128 | -17.621931644 | 0.236483528 | | N00.sol / average | 0.95 | 0.27 | 0.1 | 0.005 | 10000..10127 | 128 | -0.038082529 | 0.036111760 | | N01.sol / average | 0.95 | 0.27 | 1 | 0.005 | 10000..10127 | 128 | -1.395998877 | 0.085086750 | | N02.sol / average | 0.95 | 0.24 | 0.1 | 0.005 | 10000..10127 | 128 | -0.027996403 | 0.051915060 | | N03.sol / average | 0.95 | 0.24 | 1 | 0.005 | 10000..10127 | 128 | -1.274118577 | 0.080879061 | | N04.sol / average | 0.95 | 0.24 | 4 | 0.005 | 10000..10127 | 128 | -4.186913295 | 0.121834013 | | N05.sol / average | 0.95 | 0.25 | 0.1 | 0.05 | 10000..10127 | 128 | -0.132278524 | 0.048233183 | | N06.sol / average | 0.95 | 0.25 | 0.3 | 0.05 | 10000..10127 | 128 | -0.730071481 | 0.074741054 | | N07.sol / average | 0.95 | 0.26 | 0.03 | 0.5 | 10000..10127 | 128 | -0.063027634 | 0.037394382 | | N08.sol / average | 0.95 | 0.26 | 0.1 | 0.15 | 10000..10127 | 128 | -0.367579146 | 0.073462958 | | N09.sol / average | 0.99 | 0.26 | 0.1 | 0.05 | 10000..10127 | 128 | -0.169755274 | 0.049265597 | | N10.sol / average | 0.9 | 0.26 | 0.1 | 0.05 | 10000..10127 | 128 | -0.088884964 | 0.045704700 | | N11.sol / average | 0.95 | 0.27 | 0.003 | 0.5 | 10000..10127 | 128 | 0.007543721 | 0.014697267 | | N11.sol / average | 0.95 | 0.27 | 0.003 | 0.5 | 20000..20511 | 512 | 0.005889873 | 0.007235752 | | N02.sol / average | 0.95 | 0.24 | 0.1 | 0.005 | 20000..20511 | 512 | -0.065314857 | 0.020435519 | | B00.sol / average | 0.95 | 0.27 | 0.01 | 0.5 | 20000..20511 | 512 | -0.006556690 | 0.012434190 | | N00.sol / average | 0.95 | 0.27 | 0.1 | 0.005 | 20000..20511 | 512 | -0.085795039 | 0.016740082 | Frozen selection: **N11.sol**, (A1,A0,priorOdds,sizeScale)=(0.95, 0.27, 0.003, 0.5); frozen SHA-256 `ec3e457fe74585b998010cf49f4482e822533f7d60668c75bfe54c504ccfca90`. Selection used the 512-seed block only after the 128-seed shortlist was fixed. No tuning followed the freeze or used confirmation seeds. **No demonstrated improvement; retain NP2.** Confirmation mean edge: candidate 522.468604131609, NP2 522.468821210848. The point estimates near zero are not evidence of progress toward the requested ranking. Checks: both requested baseline means reproduced; selected strategy passed `amm-match validate`; arithmetic model checks passed (bounded alpha, monotonic gap and size effects, finite zero-sigma case). Selected bytecode initialized and completed 100 synthetic callbacks with fees in [0,0.1] and no callback failures. These callback checks are diagnostic, not score measurements. An equal-alpha control (A1=A0=0.27, side band, prior=1, scale=0.5) matched NP2 on seeds 10000..10015: n=16, mean_diff=2.62616595136933e-11, se=2.9080375871063e-11, worst=-1.76328285306226e-10. This tiny difference reflects fixed-point/float rounding. The escape model uses a rational variance-to-band proxy and an unnormalized size likelihood with its normalization absorbed into tuned prior odds. It does not identify arbitrage exactly, does not correct sigmaHat's interpretation as an innovation EMA, and does not independently retune NP2's fee equations. These limitations can explain why a more aggressive first-print alpha need not improve edge. Method: simulator pinned at `6b6921f8d463314aa7c96234e1be25a25245f704`; supplied item setup.sh ran once and validated StarterStrategy. Config draws follow [MatchRunner._build_configs](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/match.py) with default_rng(seed), drawing size U(19,21), rate U(0.6,1), sigma U(0.000882,0.001008), in that order; [settings](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/config.py) otherwise unchanged (10,000 steps). The [engine](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/simulation/engine.rs) uses price seed=s and retail seed=s+1. Each candidate and NP2 runs separately against [Vanilla](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/VanillaStrategy.sol) through [run_batch](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/lib.rs) with 8 workers, 16 seeds per call. Differences pair edges['submission'] by seed. SE=std(d,ddof=1)/sqrt(n); worst=min(d). No candidate-versus-NP2 shared-market runs. Baseline checks, seeds 0..999: [CH](https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol) = 525.5258821780834; NP2 = 526.1155722459862. NP2 was reconstructed from [TWO](https://api.imdnotdead.fun/artifacts/528a6da78583c6142644a552c86670f9d25c20e39e92f4de44deae05ddc8cecd) plus the requested [NP](https://api.imdnotdead.fun/artifacts/da313379a2e69e9286668865e06b18dfcae25732c82b934b0fd9c2ef0d8c2ff5) routing block; SHA-256 `51f1c1a9d4999ee460eb8bbc66880da8074b173399a4f5d71f96671482e18ac0`. Compilation uses the pinned [compiler](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/evm/compiler.py). The [arbitrage formulas](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/market/arbitrageur.rs) motivate the fee-adjusted implied-price observation; the posterior is our heuristic. The [CFMM](https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/amm/cfmm.rs) keeps fees outside liquidity. ## paired Frozen candidate: `N11.sol`. Confirmation block: **2620000..2621999**, evaluated once after selection. Same measurement protocol as tuning. ```json { "n": 2000, "mean_diff": -0.00021707923826105004, "se": 0.0036910362339696895, "worst": -0.8421897563255243 } ``` ## blocked null ## next Condition the escape prior on the estimated starting position within the asymmetric no-arbitrage band, rather than band width alone; test it separately on unused tuning seeds.