{ "approach": "Fresh arb-probability gate on CH 6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3. Frozen grid winner p1n5: s=1, retail noise multiplier=0.5. Gaussian density of log(pImplied/pHat) with scale s*sigmaHat*sqrt(elapsedRaw) versus independent Gaussian retail move noise and lognormal amountY, arithmetic mean .002*post-trade Y reserves, log sigma1.2. To make the joint likelihood dimensionless, the arb size density is taken flat with characteristic ratio .002; kernel prior odds=1/lambdaHat. Gaussian normalizers are absorbed into those odds; with a fully normalized retail size density the equivalent prior odds are1/(sqrt(2*pi)*lambdaHat). These are explicit modeling assumptions, not calibrated posterior probabilities. First print at timestamp0 uses elapsed1; floors and saturation are numerical safeguards. Later-print CH updates unchanged. Variant names pn5/pn10 denote s in1,2,4 and retail noise.5/1.0 respectively. All six candidates tuned on the same 500 seeds10000..10499; frozen by maximum paired tuning mean before candidate holdout execution. Evaluated candidate exactly once on600000..601999, chunks50, against separately cached CH edges from identical configurations and normalizer30bps, never head-to-head CH versus candidate. Configuration draws: numpy default_rng(seed), uniform size19..21, rate.6..1, sigma.000882...001008 in that order; Rust price seed=seed, retail seed=seed+1; 10000steps. Forbidden seeds900000..909999 never run. SE uses sample sd/sqrt(n). Score CH525.525882178 on0..999 is requester-supplied, not remeasured. No claim of gain over starter (not measured). No loops remain in Strategy.sol. CH _powWad is mechanically unrolled into four fixed bit steps for the elapsed cap8; no extra storage. Tuning measurements predate that equivalent unroll. Protocol deviation: pre-unroll source9f0f3108de5e982cd67cf161f050c0dc5eecefb850384f6d7afe0a07c7aefac0 had350 stored holdout pairs and350 stored score seeds before controlled stop; those results were discarded solely for no-loop compliance. Thus these seed ranges were partially executed before the final-source run, rather than literally executed only once. No gate parameter or economic behavior changed using those results, and no duplicate observations are counted. The final no-loop source is frozen and measured once. Unroll equivalence checks: {\"all_exponents_0_to_8_equivalent\": true, \"all_actual_decay_factors_checked\": true, \"sequential_synthetic_callback_fee_pairs_equal\": 400, \"all_32_storage_slots_equal_after_each_callback\": true, \"new_sha256\": \"e4f0b91e104fa812a6bb2cf3f07635b2780bd0acdab7f113cf73cb504d68ab5c\", \"pre_unroll_vs_final_simulation_edges_bit_exact\": {\"600000\": 350, \"0\": 350}, \"comparison_observations_not_added_to_statistical_n\": true}. Rust enforces250000gas per callback. Final candidate holdout and score use the pinned engine with scratch-only audit instrumentation: callback errors panic instead of silently retaining old fees, and an atomic counter records observed maximum afterSwap gas, without changing successful EVM execution or market math. Audit equivalence on training seeds10000..10002: {\"compared_seeds\": [10000, 10001, 10002], \"edges_exactly_equal\": true, \"max_swap_gas\": 132590}. Both final runs complete without callback failure; observed maximum gas=162473. Independent math checks: {\"samples\": 150, \"max_abs_log_error\": 1.0022392871178454e-07, \"sqrt_exact\": true, \"exp_abs_error_bound\": 0.0001}. Synthetic callback checks: {\"callback_count\": 240, \"callback_gas_limit\": 250000, \"reverts\": 0, \"fees_in_bounds\": true, \"scope\": \"Synthetic states on pre-unroll p1n5 bytecode; not simulation measurements.\"}. Public Algebra write-up describes first-trade ordering and probabilistic estimation; it supplies context, not parameters. The dipankar public postmortem contrasts trade classification with hidden-state estimation; its reported performance was not independently replicated here. The Paradigm puzzle landing page was inaccessible through the browser tool; the pinned simulator source supplied the rules and execution reference. seconds_per_simulation is frozen holdout wall time/n, includes concurrent-run contention. Promotion criterion is fresh paired mean>2SE; promotion=False.", "tried": [ { "variant": "p1n5", "seeds": "10000..10499", "n": 500, "mean_diff": -5.462914383515756, "se": 0.09777393469666615 }, { "variant": "p2n5", "seeds": "10000..10499", "n": 500, "mean_diff": -5.979681112783315, "se": 0.08942030609982943 }, { "variant": "p4n5", "seeds": "10000..10499", "n": 500, "mean_diff": -7.132808487642508, "se": 0.09308336419268802 }, { "variant": "p2n10", "seeds": "10000..10499", "n": 500, "mean_diff": -9.474383861480211, "se": 0.09794943829511495 }, { "variant": "p1n10", "seeds": "10000..10499", "n": 500, "mean_diff": -10.478427374813055, "se": 0.26203168778096786 }, { "variant": "p4n10", "seeds": "10000..10499", "n": 500, "mean_diff": -12.081596895606625, "se": 0.1128410948371972 } ], "next": "Do not promote: retain CH. The prescribed soft posterior gate failed the fresh paired >2SE criterion; investigate likelihood misspecification or the loss of CH first-print update strength before further tuning.", "code": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {AMMStrategyBase} from \"./AMMStrategyBase.sol\";\nimport {TradeInfo} from \"./IAMMStrategy.sol\";\n\ncontract Strategy is AMMStrategyBase {\n uint256 constant PRIOR_SCALE = 1;\n uint256 constant RETAIL_NOISE = 500000000000000000;\n uint256 constant ELAPSED_CAP = 8;\n uint256 constant SIGNAL_THRESHOLD = WAD / 650;\n uint256 constant DIR_DECAY = 750000000000000000;\n uint256 constant ACT_DECAY = 530000000000000000;\n uint256 constant SIZE_DECAY = 530000000000000000;\n uint256 constant TOX_DECAY = 910000000000000000;\n uint256 constant SIGMA_DECAY = 690000000000000000;\n uint256 constant LAMBDA_DECAY = 990000000000000000;\n uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n uint256 constant PHAT_ALPHA = 270000000000000000;\n uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n uint256 constant DIR_IMPACT_MULT = 4;\n uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n uint256 constant MIN_GATE = 30000000000000000;\n uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n uint256 constant RET_CAP = WAD / 35;\n uint256 constant TOX_CAP = WAD / 5;\n uint256 constant TRADE_RATIO_CAP = WAD / 5;\n uint256 constant LAMBDA_CAP = 1820000000000000000;\n uint256 constant STEP_COUNT_CAP = 64;\n uint256 constant BASE_FEE = 4 * BPS;\n uint256 constant SIGMA_COEF = 200000000000000000;\n uint256 constant LAMBDA_COEF = 12 * BPS;\n uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n uint256 constant TOX_COEF = 300 * BPS;\n uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n uint256 constant ACT_COEF = 91843 * BPS;\n uint256 constant DIR_COEF = 20 * BPS;\n uint256 constant DIR_TOX_COEF = 100 * BPS;\n uint256 constant STALE_DIR_COEF = 6850 * BPS;\n uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n uint256 constant TAIL_KNEE = 600 * BPS;\n uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[2] = 0; slots[3] = WAD; slots[4] = 0;\n slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n slots[9] = 0; slots[10] = 0;\n return (BASE_FEE, BASE_FEE);\n }\n\n function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = slots[2];\n uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n bool isNewStep = trade.timestamp > lastTs;\n if (isNewStep) {\n uint256 elapsedRaw = trade.timestamp - lastTs;\n uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n if (stepTradeCount > 0 && elapsedRaw > 0) {\n uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n }\n stepTradeCount = 0;\n }\n\n bool firstInStep = stepTradeCount == 0;\n uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n if (pHat == 0) pHat = spot;\n\n uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n uint256 pImplied;\n if (gamma == 0) { pImplied = spot; }\n else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n {\n uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n if (firstInStep) {\n uint256 prob = _arbProbability(trade, pImplied, pHat, sigmaHat, toxEma, lambdaHat, lastTs);\n uint256 alpha = wmul(PHAT_ALPHA, prob);\n pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha);\n if (ret > RET_CAP) ret = RET_CAP;\n uint256 weight = wmul(WAD - SIGMA_DECAY, prob);\n sigmaHat = wmul(sigmaHat, WAD - weight) + wmul(ret, weight);\n } else {\n uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n if (ret <= adaptiveGate) pHat = wmul(pHat, WAD - PHAT_ALPHA_RETAIL) + wmul(pImplied, PHAT_ALPHA_RETAIL);\n }\n }\n\n uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n if (tradeRatio > SIGNAL_THRESHOLD) {\n uint256 push = tradeRatio * DIR_IMPACT_MULT;\n if (push > WAD / 4) push = WAD / 4;\n if (trade.isBuy) {\n dirState = dirState + push;\n if (dirState > 2 * WAD) dirState = 2 * WAD;\n } else {\n dirState = dirState > push ? dirState - push : 0;\n }\n actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n if (sizeHat > WAD) sizeHat = WAD;\n }\n\n uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n if (tox > TOX_CAP) tox = TOX_CAP;\n toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n uint256 toxSignal = toxEma;\n\n stepTradeCount = stepTradeCount + 1;\n if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n uint256 flowSize = wmul(lambdaHat, sizeHat);\n uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));\n\n uint256 dirDev; bool sellPressure;\n if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }\n else { dirDev = WAD - dirState; sellPressure = false; }\n\n uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n uint256 bidFee; uint256 askFee;\n if (sellPressure) {\n bidFee = fMid + skew;\n askFee = fMid > skew ? fMid - skew : 0;\n } else {\n askFee = fMid + skew;\n bidFee = fMid > skew ? fMid - skew : 0;\n }\n\n {\n uint256 staleShift = wmul(STALE_DIR_COEF, toxSignal);\n uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n if (spot >= pHat) {\n bidFee = bidFee + staleShift;\n askFee = askFee > attractShift ? askFee - attractShift : 0;\n } else {\n askFee = askFee + staleShift;\n bidFee = bidFee > attractShift ? bidFee - attractShift : 0;\n }\n }\n\n {\n bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n if (tradeAligned) {\n uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);\n if (trade.isBuy) { bidFee = bidFee + tradeBoost; }\n else { askFee = askFee + tradeBoost; }\n }\n }\n\n if (sellPressure) {\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));\n } else {\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));\n }\n\n slots[0] = bidFee; slots[1] = askFee; slots[2] = trade.timestamp;\n slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;\n slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;\n slots[9] = toxEma; slots[10] = stepTradeCount;\n\n return (bidFee, askFee);\n }\n\n function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) {\n if (fee <= TAIL_KNEE) return fee;\n return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope);\n }\n\n function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) {\n result = WAD;\n // Every caller caps elapsed at 8: at most four exponent bits.\n if (exp & 1 == 1) result = wmul(result, factor);\n factor = wmul(factor, factor); exp >>= 1;\n if (exp & 1 == 1) result = wmul(result, factor);\n factor = wmul(factor, factor); exp >>= 1;\n if (exp & 1 == 1) result = wmul(result, factor);\n factor = wmul(factor, factor); exp >>= 1;\n if (exp & 1 == 1) result = wmul(result, factor);\n }\n\n function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) {\n uint256 mul = _powWad(decayFactor, elapsed);\n if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); }\n uint256 below = wmul(WAD - centered, mul);\n return below < WAD ? WAD - below : 0;\n }\n\n\n // Gaussian move likelihood versus retail move noise and lognormal size.\n // Equal-density size reference for arb: 0.002 of Y reserves.\n function _arbProbability(TradeInfo calldata t, uint256 implied, uint256 ph,\n uint256 sig, uint256 tox, uint256 lambda, uint256 last) internal pure returns (uint256) {\n uint256 elapsed = t.timestamp > last ? t.timestamp - last : 1;\n if (elapsed > 10000) elapsed = 10000;\n uint256 arbScale = wmul(sig, _root(elapsed * WAD * WAD)) * PRIOR_SCALE;\n if (arbScale < 1e12) arbScale = 1e12;\n uint256 noise = wmul(tox, RETAIL_NOISE);\n if (noise < 1e14) noise = 1e14;\n int256 move = _ln(wdiv(implied > 0 ? implied : 1, ph > 0 ? ph : 1));\n uint256 ratio = t.reserveY > 0 ? wdiv(t.amountY, t.reserveY) : 1;\n if (ratio < 1e10) ratio = 1e10;\n if (ratio > WAD) ratio = WAD;\n int256 sizeZ = (_ln(wdiv(ratio, 2e15)) + 720000000000000000) * 5 / 6;\n int256 odds = _ln(wdiv(noise, arbScale)) + _ln(wdiv(wmul(ratio, 12e17), 2e15))\n + int256(_squareZ(move, noise) / 2) + int256(_squareZ(sizeZ, WAD) / 2)\n - int256(_squareZ(move, arbScale) / 2)\n - _ln(lambda > 1e14 ? lambda : 1e14);\n if (odds >= 32e18) return WAD;\n if (odds <= -32e18) return 0;\n uint256 e = _expNeg(uint256(odds < 0 ? -odds : odds));\n return odds >= 0 ? wdiv(WAD, WAD + e) : wdiv(e, WAD + e);\n }\n function _squareZ(int256 x, uint256 scale) internal pure returns (uint256) {\n uint256 z = wdiv(uint256(x < 0 ? -x : x), scale);\n if (z > 16e18) z = 16e18;\n return wmul(z, z);\n }\n // Range reduction then odd atanh polynomial, bounded and loop-free.\n function _ln(uint256 v) internal pure returns (int256) {\n if (v == 0) v = 1;\n int256 k;\n if (v < WAD) { v = WAD * WAD / v; k = 1; }\n uint256 n;\n if (v >= WAD * 2**32) { v >>= 32; n += 32; }\n if (v >= WAD * 2**16) { v >>= 16; n += 16; }\n if (v >= WAD * 2**8) { v >>= 8; n += 8; }\n if (v >= WAD * 2**4) { v >>= 4; n += 4; }\n if (v >= WAD * 2**2) { v >>= 2; n += 2; }\n if (v >= WAD * 2) { v >>= 1; n += 1; }\n uint256 z = wdiv(v - WAD, v + WAD);\n uint256 z2 = wmul(z,z);\n uint256 poly = WAD/11;\n poly = WAD/9 + wmul(z2,poly);\n poly = WAD/7 + wmul(z2,poly);\n poly = WAD/5 + wmul(z2,poly);\n poly = WAD/3 + wmul(z2,poly);\n int256 r = int256(n * 693147180559945309 + 2 * wmul(z, WAD + wmul(z2,poly)));\n return k == 1 ? -r : r;\n }\n function _expNeg(uint256 x) internal pure returns (uint256) {\n // exp(-x) via reciprocal of (1+x/4096)^4096.\n uint256 y = WAD + x / 4096;\n y=wmul(y,y); y=wmul(y,y); y=wmul(y,y); y=wmul(y,y);\n y=wmul(y,y); y=wmul(y,y); y=wmul(y,y); y=wmul(y,y);\n y=wmul(y,y); y=wmul(y,y); y=wmul(y,y); y=wmul(y,y);\n return wdiv(WAD,y);\n }\n function _root(uint256 x) internal pure returns (uint256 r) {\n uint256 v=x; r=1;\n if(v>>128>0){v>>=128;r<<=64;} if(v>>64>0){v>>=64;r<<=32;}\n if(v>>32>0){v>>=32;r<<=16;} if(v>>16>0){v>>=16;r<<=8;}\n if(v>>8>0){v>>=8;r<<=4;} if(v>>4>0){v>>=4;r<<=2;} if(v>>2>0){r<<=1;}\n r=(r+x/r)>>1; r=(r+x/r)>>1; r=(r+x/r)>>1; r=(r+x/r)>>1;\n r=(r+x/r)>>1; r=(r+x/r)>>1; r=(r+x/r)>>1;\n uint256 other=x/r; if(other