{"variant":"feat-a","blocked":null,"gates":{"A":{"passed":true,"number":7.60422131512728e-05,"unit":"max |fee diff| bps, port vs HA code on EVM","sequences":50,"swap_callbacks":100000,"seeds":[310000,310049],"threshold_bps":0.01},"B":{"passed":true,"number":1.127066774560329,"se":0.016115612191653444,"n":4096,"seeds":[31000000,31004095],"required_interval":[1.107,1.407]},"C":{"passed":true,"number":0.0001210463733067324,"unit":"max |fee diff| bps, frozen port vs frozen Solidity","sequences":50,"swap_callbacks":100000,"seeds":[310000,310049],"threshold_bps":0.1}},"sim_markets_per_s":925.17,"sim_speed":{"feat_a_or_HA_policy":925.17,"T":1292.15,"scope":"4096 10000-step markets, numba prange on 12 cores, compilation excluded"},"search_minutes":56.03,"curve":[[0.0,1.1515,0.0214],[5.11,1.2038,0.0219],[10.22,1.3337,0.0217],[15.32,1.3894,0.0221],[20.39,1.4087,0.0209],[25.54,1.4448,0.022],[30.63,1.5551,0.0223],[35.75,1.5923,0.0229],[40.9,1.6399,0.0232],[46.04,1.7005,0.0233],[51.11,1.7286,0.0241],[56.03,1.7286,0.0241]],"curve_note":"[search minutes, best-so-far monitor gain over T, se] on monitor seeds 30000000-30002047 (paired vs T); point 0 is the start policy (= HA).","holdout":{"n":8192,"seeds":[40000000,40008191],"gain_over_T":1.6810993802820697,"se":0.01168037545924071,"gain_over_HA":0.56426731778212,"se_HA":0.007110998276386875,"HA_gain_over_T":1.1168320624999497,"HA_se":0.010208617421586826},"real":{"seeds":[7004000,7004511],"runs_per_seed_per_arm":1,"vs_T":{"n":512,"mean_diff":1.6503959601829377,"se":0.046093280857813376,"worst5":[{"seed":7004096,"diff":-2.383731231137972},{"seed":7004119,"diff":-1.602726088212421},{"seed":7004120,"diff":-1.55417570105692},{"seed":7004236,"diff":-1.3687137121699493},{"seed":7004398,"diff":-1.189081967707068}]},"vs_HA":{"n":512,"mean_diff":0.5686223518086074,"se":0.028821197274498403,"worst5":[{"seed":7004485,"diff":-1.8116939326319539},{"seed":7004044,"diff":-1.2449877316763605},{"seed":7004096,"diff":-1.2308544970569528},{"seed":7004051,"diff":-1.1456148932178394},{"seed":7004025,"diff":-1.0022619954091283}]},"retail_delta":0.5262798001588296,"retail_delta_se":0.030247123368554084,"arb_delta":0.042342551649777675,"arb_delta_se":0.012744405267231506,"reconciliation_max_abs":1.1368683772161603e-13,"HA_vs_T":{"n":512,"mean_diff":1.0817736083743301,"se":0.03902021241476839},"arm_mean_edge":{"T":533.033142172777,"HA":534.1149157811514,"final":534.6835381329599},"arm_sha256":{"T":"ebd9de9bf6af6e55d5e308fd15dbb88edec11fd684891d02a30aec185acd19b3","HA":"99e3a2eceae0e5543d27473859e10b005d0ce0aa7067f2e1a24d1e0e4a7390fe","final":"aa2c4a5637a4060088263d71ab8b109339b101bb25d64a45e9c7de83710d8728"}},"gas":{"afterSwap_max_ok":234741,"init_max_ok":243227,"oog":0,"other_failures":0,"afterSwap_calls":5522922,"HA_afterSwap_max_ok":231604,"T_afterSwap_max_ok":223348,"pre_training_probe":{"seeds":[7000000,7000015],"afterSwap_max_ok":231279,"init_max_ok":243227,"oog":0,"other_failures":0,"note":"19-input head, all extra weights 1e-6 so every term is emitted"}},"valid":true,"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 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 PHAT_ALPHA_SAME = 120000000000000000;\n    uint256 constant REVERT_U = 0;\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[3] = WAD; \n        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n        slots[15] = 400000000000000000 | (uint256(2000000000000000) << 160); slots[13] = 902500000000; slots[14] = slots[5]; \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 = uint64(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        uint256 sigmaForFast = sigmaHat;\n        uint256 fastHat = slots[14];\n        uint256 uncertainty = slots[13];\n        uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\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            // Process variance is propagated inside the censored update.\n            if (uncertainty > 100000000000000) uncertainty = 100000000000000;\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        // S: infer a no-trade interval center from the last post-trade spot.\n        uint256 silenceScale = WAD;\n        if (firstInStep && silent > 1) {\n            uint256 g = silent - 1;\n            if (g > 1) g = 1;\n            uint256 w = WAD - _powWad(800000000000000000, g);\n            uint256 s = slots[2] >> 64;\n            if (s == 0) s = pHat;\n            uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n            if (c >= pHat) pHat += wmul(w, c - pHat);\n            else pHat -= wmul(w, pHat - c);\n            silenceScale = WAD - wmul(300000000000000000, w);\n        }\n\n        {\n            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n            uint256 prePhat = pHat;\n            bool secondPrint = !firstInStep && stepTradeCount == 1;\n            bool sameDir = false; bool oppDir = false;\n            if (secondPrint) {\n                bool up2 = pImplied >= pHat;\n                uint256 d1 = slots[12];\n                if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n                if (sameDir) alpha = PHAT_ALPHA_SAME;\n            }\n            if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n            alpha = wmul(alpha, silenceScale);\n            adaptiveGate = wmul(adaptiveGate, silenceScale);\n            if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n            if (oppDir && REVERT_U > 0) {\n                uint256 pre = slots[11];\n                if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n                else pHat = pHat - wmul(pHat - pre, REVERT_U);\n            }\n            if (firstInStep) {\n                if (ret > RET_CAP) ret = RET_CAP;\n                sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n            }\n        }\n\n        // Interior retail routing equalizes fee-adjusted marginal prices.\n        // Subsequent trades in a step cannot be the initial arbitrage trade.\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalSpot = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n        }\n\n        // Censored assumed-density posterior. No external or future inputs.\n        uint256 arbProbability;\n        (fastHat, uncertainty, arbProbability) = _posterior(PosteriorInput(\n            fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n            prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n            trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n        ));\n        slots[13] = uncertainty;\n        slots[14] = fastHat;\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        uint256 toxLinear;\n        uint256 toxQuadratic;\n        {\n            uint256 packedAnchor = slots[16];\n            uint256 runMean = uint64(packedAnchor);\n            uint256 sampleCount = packedAnchor >> 64;\n            if (sampleCount < 674) sampleCount++;\n            if (toxEma >= runMean) runMean += (toxEma-runMean)/sampleCount;\n            else runMean -= (runMean-toxEma)/sampleCount;\n            slots[16] = runMean | (sampleCount << 64);\n            toxLinear = _anchorBlend(runMean, toxEma, 712696014807650816);\n            toxQuadratic = _anchorBlend(runMean, toxEma, 1295240753826310656);\n        }\n\n\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n        uint256 originalLambda = lambdaHat; uint256 originalSize = sizeHat;\n\n        if (342406799193418304 > 0) {\n            uint256 packedFlow = slots[15];\n            uint256 rate = uint80(packedFlow);\n            uint256 count = uint80(packedFlow >> 80);\n            uint256 meanSize = uint80(packedFlow >> 160);\n            if (rate == 0) rate = 400000000000000000;\n            if (meanSize == 0) meanSize = 2000000000000000;\n            if (isNewStep) {\n                uint256 inst = count / silent;\n                if (inst > 3 * WAD) inst = 3 * WAD;\n                uint256 retention = _powWad(999000000000000000, silent > 64 ? 64 : silent);\n                rate = wmul(rate, retention) + wmul(inst, WAD-retention);\n                count = 0;\n            }\n            uint256 weight = firstInStep ? WAD-arbProbability : WAD;\n            uint256 correctedWeight = weight;\n            if (2 == 2) {\n                uint256 missing = wmul(feeUsed, 196030880396139429888);\n                if (missing > 333333333333333376) missing = 333333333333333376;\n                correctedWeight = wdiv(weight, WAD-missing);\n            }\n            count += correctedWeight;\n            uint256 learning = wmul(WAD-999000000000000000, weight);\n            meanSize = _blend(meanSize, tradeRatio, learning);\n            slots[15]=rate | (count << 80) | (meanSize << 160);\n            uint256 retailRate = wmul(rate, 366383424913407168);\n            uint256 retailSize = 2 == 0 ? sizeHat : wmul(meanSize,1883296158119298304);\n            lambdaHat = _blend(lambdaHat,retailRate,342406799193418304);\n            sizeHat = _blend(sizeHat,retailSize,342406799193418304);\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, toxLinear) + wmul(TOX_QUAD_COEF, wmul(toxQuadratic, toxQuadratic)) + wmul(ACT_COEF, actEma);\n        fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxLinear));\n\n        lambdaHat = originalLambda; sizeHat = originalSize;\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 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n            uint256 staleTox = wdiv(absDiff(spot, staleHat), staleHat);\n            if (staleTox > TOX_CAP) staleTox = TOX_CAP;\n            uint256 staleShift = wmul(STALE_DIR_COEF, staleTox);\n            uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n            if (spot >= staleHat) {\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 (!firstInStep && tradeBoost > 16 * BPS) tradeBoost = 16 * BPS;\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        if (firstInStep) {\n            if (askFee > bidFee && bidFee > 30 * BPS) bidFee = 30 * BPS;\n            else if (bidFee > askFee && askFee > 30 * BPS) askFee = 30 * BPS;\n        }\n\n        if (bidFee > askFee && askFee > 36 * BPS) askFee = 36 * BPS;\n        else if (askFee > bidFee && bidFee > 36 * BPS) bidFee = 36 * BPS;\n\n        {\n            int256[19] memory nx;\n            unchecked {\n                nx[0] = int256(sigmaHat)*1000/1e12-1000000;\n                nx[1] = int256(lambdaHat)*2/1e12-1000000;\n                nx[2] = int256(sizeHat)*500/1e12-1000000;\n                nx[3] = int256(toxEma)*500/1e12-1000000;\n                nx[4] = int256(actEma)*500/1e12-1000000;\n                nx[5] = int256(dirState)/1e12-1000000;\n                uint256 nh = wmul(pHat,700000000000000000)+wmul(fastHat,300000000000000000);\n                nx[6] = (int256(spot)-int256(nh))*500000000/int256(nh);\n                nx[7] = int256(tradeRatio)*500/1e12;\n                if (!trade.isBuy) nx[7] = -nx[7];\n                nx[8] = int256(arbProbability)*2/1e12-1000000;\n                nx[9] = firstInStep ? int256(1000000) : -int256(1000000);\n                nx[10] = int256(uncertainty)/1e6-1000000;\n                nx[11] = int256(silent>8 ? 8 : silent)*1000000/8;\n                nx[12] = int256(uint256(uint64(slots[16])))*500/1e12-1000000;\n                nx[13] = int256(bidFee)*200/1e12-1000000;\n                nx[14] = int256(askFee)*200/1e12-1000000;\n                nx[15] = int256(prevBidFee)*200/1e12-1000000;\n                nx[16] = int256(prevAskFee)*200/1e12-1000000;\n                nx[17] = (int256(spot)-int256(pHat))*500000000/int256(pHat);\n                nx[18] = int256(uint256(uint80(slots[15])))*2/1e12-1000000;\n                for (uint256 ni=0;ni<19;ni++) {\n                    if(nx[ni]>4000000) nx[ni]=4000000;\n                    if(nx[ni]<-4000000) nx[ni]=-4000000;\n                }\n                (int256 hb,int256 ha) = _head(nx);\n                int256 nb = int256(bidFee)+hb*100000000;\n                int256 na = int256(askFee)+ha*100000000;\n                bidFee = nb<0 ? 0 : (nb>int256(MAX_FEE) ? MAX_FEE : uint256(nb));\n                askFee = na<0 ? 0 : (na>int256(MAX_FEE) ? MAX_FEE : uint256(na));\n            }\n        }\n\n        slots[0] = bidFee; slots[1] = askFee; slots[2] = (spot << 64) | 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\n\n    function _head(int256[19] memory x) internal pure returns (int256 b,int256 a) {\n        unchecked {\n            b = 236450000000; a = 2596366000000;\n            int256 z;\n            z = 2097202 + ((415410 * x[0]) + (2625494 * x[1]) + (-552797 * x[2]) + (2617680 * x[3]) + (-2951257 * x[4]) + (119446 * x[5]) + (-3454543 * x[6]) + (-130464 * x[7]) + (-4180482 * x[8]) + (-20483 * x[9]) + (-696185 * x[10]) + (821209 * x[11]) + (368503 * x[12]) + (800388 * x[13]) + (1365120 * x[14]) + (115940 * x[15]) + (70658 * x[16]) + (425678 * x[17]) + (550247 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (610442 * z); a += (637392 * z);\n            z = -2700747 + ((826483 * x[0]) + (1670343 * x[1]) + (1625203 * x[2]) + (3541027 * x[3]) + (1953008 * x[4]) + (523761 * x[5]) + (712603 * x[6]) + (-306419 * x[7]) + (30773 * x[8]) + (103124 * x[9]) + (-380698 * x[10]) + (102332 * x[11]) + (904122 * x[12]) + (-1278882 * x[13]) + (1023807 * x[14]) + (-5028 * x[15]) + (435202 * x[16]) + (19800 * x[17]) + (-637520 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-1871713 * z); a += (-1446095 * z);\n            z = -2855195 + ((1762690 * x[0]) + (2357321 * x[1]) + (-1322141 * x[2]) + (1584500 * x[3]) + (2339261 * x[4]) + (3520750 * x[5]) + (-326077 * x[6]) + (2394657 * x[7]) + (1598474 * x[8]) + (-1133809 * x[9]) + (-281646 * x[10]) + (-1804465 * x[11]) + (-1026689 * x[12]) + (228433 * x[13]) + (-2135998 * x[14]) + (1047193 * x[15]) + (-422202 * x[16]) + (-938828 * x[17]) + (554366 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-62359 * z); a += (-1364995 * z);\n            z = -163861 + ((-660370 * x[0]) + (-657432 * x[1]) + (641931 * x[2]) + (772477 * x[3]) + (-315574 * x[4]) + (1880929 * x[5]) + (232721 * x[6]) + (1179756 * x[7]) + (-818173 * x[8]) + (1022032 * x[9]) + (611346 * x[10]) + (-863671 * x[11]) + (-2369790 * x[12]) + (-390564 * x[13]) + (589984 * x[14]) + (194244 * x[15]) + (2617808 * x[16]) + (-8710 * x[17]) + (-184773 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-222805 * z); a += (2318799 * z);\n            z = 368394 + ((667105 * x[0]) + (-1662614 * x[1]) + (3710663 * x[2]) + (-1099943 * x[3]) + (-3211229 * x[4]) + (-1687362 * x[5]) + (-1516088 * x[6]) + (-814365 * x[7]) + (330405 * x[8]) + (-188594 * x[9]) + (92073 * x[10]) + (-3103254 * x[11]) + (-45199 * x[12]) + (586768 * x[13]) + (549850 * x[14]) + (-277598 * x[15]) + (1362595 * x[16]) + (875048 * x[17]) + (744305 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-3859125 * z); a += (587007 * z);\n            z = -1742600 + ((1306201 * x[0]) + (-195204 * x[1]) + (825063 * x[2]) + (-726541 * x[3]) + (2514743 * x[4]) + (1141709 * x[5]) + (295602 * x[6]) + (-148600 * x[7]) + (-1828924 * x[8]) + (674060 * x[9]) + (123563 * x[10]) + (3283964 * x[11]) + (972392 * x[12]) + (-399466 * x[13]) + (-237829 * x[14]) + (539019 * x[15]) + (-699159 * x[16]) + (-410170 * x[17]) + (336302 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-417720 * z); a += (-949508 * z);\n            z = -1634150 + ((-1600728 * x[0]) + (1326864 * x[1]) + (894166 * x[2]) + (-2981901 * x[3]) + (1130169 * x[4]) + (-162328 * x[5]) + (507105 * x[6]) + (266489 * x[7]) + (1115566 * x[8]) + (-33268 * x[9]) + (-155503 * x[10]) + (522530 * x[11]) + (-1328877 * x[12]) + (1521563 * x[13]) + (-419090 * x[14]) + (652718 * x[15]) + (848083 * x[16]) + (-81342 * x[17]) + (813151 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (-591765 * z); a += (-50367 * z);\n            z = -661716 + ((-1092411 * x[0]) + (-2434060 * x[1]) + (2632868 * x[2]) + (2382890 * x[3]) + (-1321667 * x[4]) + (-1665258 * x[5]) + (-457378 * x[6]) + (1669463 * x[7]) + (1744703 * x[8]) + (-1546099 * x[9]) + (2095317 * x[10]) + (-1726177 * x[11]) + (820261 * x[12]) + (330566 * x[13]) + (535138 * x[14]) + (1471106 * x[15]) + (134934 * x[16]) + (-414392 * x[17]) + (275478 * x[18]))/1000000;\n            if(z<0) z=0; else if(z>4000000) z=4000000;\n            b += (1250239 * z); a += (349325 * z);\n            b /= 1000000; a /= 1000000;\n        }\n    }\n\n    function _anchorBlend(uint256 mean, uint256 value, uint256 k) internal pure returns (uint256) {\n        if (k == WAD) return value;\n        if (value >= mean) return mean + wmul(value-mean,k);\n        uint256 delta = wmul(mean-value,k);\n        return delta < mean ? mean-delta : 0;\n    }\n\n    struct PosteriorInput {\n        uint256 mu; uint256 v; uint256 obs; uint256 spot; uint256 preSpot;\n        uint256 bid; uint256 ask; bool first; uint256 silent; bool buy; uint256 size;\n    }\n    function _posterior(PosteriorInput memory x) internal pure returns (uint256, uint256, uint256) {\n        if (x.mu == 0) x.mu = x.spot;\n        if (x.v < 10000000000) x.v = 10000000000;\n        uint256 lo = wmul(x.preSpot, WAD-x.bid);\n        uint256 hi = wdiv(x.preSpot, WAD-x.ask);\n        if (x.first) {\n            if (x.silent>1 && x.preSpot>0) {\n                uint256 elapsed=x.silent>8?8:x.silent;\n                x.v += 902500000000*(elapsed-1);\n                (x.mu,x.v)=_band(x.mu,x.v,lo,hi);\n            }\n            x.v+=902500000000;\n        }\n        uint256 mRetail = x.mu;\n        uint256 vRetail = x.v;\n        // A missing own-pool trade is a censored price observation.\n        if (x.first && x.preSpot > 0) {\n            (mRetail, vRetail) = _band(x.mu, x.v, lo, hi);\n        }\n        if (!x.first) {\n            // A later print is retail. Only an interior route is an observation\n            // of the other pool, with explicit observation uncertainty.\n            uint256 fee = x.buy ? x.bid : x.ask;\n            if (fee > 30 * BPS) {\n                uint256 normal = x.buy ? wdiv(wmul(x.spot, WAD-fee), WAD-30*BPS)\n                    : wdiv(wmul(x.spot, WAD-30*BPS), WAD-fee);\n                uint256 residual = wdiv(absDiff(normal, x.mu),x.mu);\n                uint256 noise = 9000000000000 + wmul(residual,residual);\n                uint256 k = wdiv(x.v,x.v+noise);\n                return (_blend(x.mu,normal,k),wmul(x.v,WAD-k),0);\n            }\n            return (x.mu,x.v,0);\n        }\n        uint256 e = wdiv(absDiff(x.obs,x.mu),x.mu);\n        uint256 totalV = x.v + 22500000000;\n        uint256 z = wdiv(wmul(e,e),totalV);\n        uint256 density = _powWad(wdiv(WAD,WAD+z/8),4);\n        uint256 odds = wmul(density,wdiv(4000000000000000,_isqrt(totalV*WAD)));\n        if (x.size > 3000000000000000) odds = wmul(odds,4*WAD/10);\n        if (x.silent > 1) odds = wmul(odds,8*WAD/10);\n        uint256 sd = _isqrt(x.v*WAD);\n        uint256 width = wdiv(hi-lo,x.mu);\n        uint256 distance = x.mu<lo?lo-x.mu:(x.mu>hi?x.mu-hi:0);\n        uint256 zBand = wdiv(wdiv(distance,x.mu),sd);\n        uint256 mass = wmul(wdiv(width,width+2*sd),wdiv(WAD,WAD+wmul(zBand,zBand)));\n        if (mass < WAD/100) mass = WAD/100;\n        odds = wdiv(odds,mass);\n        uint256 prob = wdiv(odds,WAD+odds);\n        uint256 kArb = wdiv(x.v,totalV);\n        uint256 mArb = _blend(x.mu,x.obs,kArb);\n        uint256 mean = _blend(mRetail,mArb,prob);\n        uint256 between = wdiv(absDiff(mArb,mRetail),x.mu);\n        uint256 variance = wmul(prob,wmul(x.v,WAD-kArb)) + wmul(WAD-prob,vRetail)\n            + wmul(wmul(prob,WAD-prob),wmul(between,between));\n        if (variance > 100000000000000) variance = 100000000000000;\n        return (mean,variance,prob);\n    }\n    function _blend(uint256 a,uint256 b,uint256 w) internal pure returns(uint256) {\n        return b>=a ? a+wmul(b-a,w) : a-wmul(a-b,w);\n    }\n    function _band(uint256 mu,uint256 v,uint256 lo,uint256 hi) internal pure returns(uint256,uint256) {\n        // Soft interval likelihood avoids discontinuities at quadrature nodes.\n        uint256 sd=wmul(mu,_isqrt(v*WAD));\n        uint256[3] memory acc;\n        for(uint256 j=0;j<7;j++) {\n            uint256 p=j<3 ? (mu>(3-j)*sd?mu-(3-j)*sd:1) : mu+(j-3)*sd;\n            uint256 w=j==3?72:(j==2||j==4?45:(j==1||j==5?10:1));\n            uint256 distance=p<lo?lo-p:(p>hi?p-hi:0);\n            uint256 z=sd>0?wdiv(distance,sd):0;\n            uint256 likelihood=wdiv(WAD,WAD+4*wmul(z,z));\n            w=wmul(w*WAD,likelihood);\n            acc[0]+=w;acc[1]+=wmul(w,p);\n            uint256 d=wdiv(absDiff(p,mu),mu);\n            acc[2]+=wmul(w,wmul(d,d));\n        }\n        uint256 m=wdiv(acc[1],acc[0]);\n        uint256 d=wdiv(absDiff(m,mu),mu);\n        uint256 second=wdiv(acc[2],acc[0]);\n        return(m,second>wmul(d,d)?second-wmul(d,d):10000000000);\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        while (exp > 0) {\n            if (exp & 1 == 1) result = wmul(result, factor);\n            factor = wmul(factor, factor);\n            exp >>= 1;\n        }\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    // Floor square root: bit-length seed and seven Newton steps (all uint256).\n    function _isqrt(uint256 x) internal pure returns (uint256 r) {\n        if (x == 0) return 0;\n        unchecked {\n            uint256 y = x;\n            r = 1;\n            if (y >> 128 != 0) { y >>= 128; r <<= 64; }\n            if (y >> 64 != 0) { y >>= 64; r <<= 32; }\n            if (y >> 32 != 0) { y >>= 32; r <<= 16; }\n            if (y >> 16 != 0) { y >>= 16; r <<= 8; }\n            if (y >> 8 != 0) { y >>= 8; r <<= 4; }\n            if (y >> 4 != 0) { y >>= 4; r <<= 2; }\n            if (y >> 2 != 0) { r <<= 1; }\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            uint256 t = x / r;\n            return r < t ? r : t;\n        }\n    }\n\n    function getName() external pure override returns (string memory) { return \"featA_leg1\"; }\n}\n","sha256":"aa2c4a5637a4060088263d71ab8b109339b101bb25d64a45e9c7de83710d8728","params":{"architecture":"19-8-2 ReLU head added to T fees (T = RS2 + toxicity anchor, unchanged)","float":{"W1":[[0.41541,2.625494,-0.552797,2.61768,-2.951257,0.119446,-3.454543,-0.130464,-4.180482,-0.020483,-0.696185,0.821209,0.368503,0.800388,1.36512,0.11594,0.070658,0.425678,0.550247],[0.826483,1.670343,1.625203,3.541027,1.953008,0.523761,0.712603,-0.306419,0.030773,0.103124,-0.380698,0.102332,0.904122,-1.278882,1.023807,-0.005028,0.435202,0.0198,-0.63752],[1.76269,2.357321,-1.322141,1.5845,2.339261,3.52075,-0.326077,2.394657,1.598474,-1.133809,-0.281646,-1.804465,-1.026689,0.228433,-2.135998,1.047193,-0.422202,-0.938828,0.554366],[-0.66037,-0.657432,0.641931,0.772477,-0.315574,1.880929,0.232721,1.179756,-0.818173,1.022032,0.611346,-0.863671,-2.36979,-0.390564,0.589984,0.194244,2.617808,-0.00871,-0.184773],[0.667105,-1.662614,3.710663,-1.099943,-3.211229,-1.687362,-1.516088,-0.814365,0.330405,-0.188594,0.092073,-3.103254,-0.045199,0.586768,0.54985,-0.277598,1.362595,0.875048,0.744305],[1.306201,-0.195204,0.825063,-0.726541,2.514743,1.141709,0.295602,-0.1486,-1.828924,0.67406,0.123563,3.283964,0.972392,-0.399466,-0.237829,0.539019,-0.699159,-0.41017,0.336302],[-1.600728,1.326864,0.894166,-2.981901,1.130169,-0.162328,0.507105,0.266489,1.115566,-0.033268,-0.155503,0.52253,-1.328877,1.521563,-0.41909,0.652718,0.848083,-0.081342,0.813151],[-1.092411,-2.43406,2.632868,2.38289,-1.321667,-1.665258,-0.457378,1.669463,1.744703,-1.546099,2.095317,-1.726177,0.820261,0.330566,0.535138,1.471106,0.134934,-0.414392,0.275478]],"b1":[2.097202,-2.700747,-2.855195,-0.163861,0.368394,-1.7426,-1.63415,-0.661716],"W2":[[0.610442,-1.871713,-0.062359,-0.222805,-3.859125,-0.41772,-0.591765,1.250239],[0.637392,-1.446095,-1.364995,2.318799,0.587007,-0.949508,-0.050367,0.349325]],"b2":[0.23645,2.596366]},"shapes":{"W1":[8,19],"b1":[8],"W2":[2,8],"b2":[2]},"weight_fixed_point_scale":1000000,"feature_fixed_point_scale":1000000,"output_unit_fee":0.0001,"feature_order":["sigmaHat","lambdaHat","sizeHat","toxEma","actEma","direction","(spot-staleHat)/staleHat","signed_trade_ratio","arb_probability","first_in_step(+1/-1)","uncertainty","min(silent,8)/8","anchor_mean","T_bid_fee","T_ask_fee","prev_bid_fee","prev_ask_fee","(spot-pHat)/pHat","retail_flow_rate"],"feature_multipliers":[1000.0,2.0,500.0,500.0,500.0,1.0,500.0,500.0,2.0,1.0,1000000.0,1.0,500.0,200.0,200.0,200.0,200.0,500.0,2.0],"feature_offsets":[-1.0,-1.0,-1.0,-1.0,-1.0,-1.0,0.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,-1.0,-1.0,-1.0,-1.0,0.0,-1.0],"feature_clip":[-4,4],"hidden_relu_clip":[0,4],"added_inputs":{"13 T_bid_fee":"bidFee after all T clamps, before the head (fraction)","14 T_ask_fee":"askFee likewise","15 prev_bid_fee":"slots[0] at callback entry","16 prev_ask_fee":"slots[1] at callback entry","17 (spot-pHat)/pHat":"signed, pHat after this callback update","18 retail_flow_rate":"uint80(slots[15]) after update (WAD units)"},"toxicity_anchor":{"count_cap":674,"linear_k_wad":712696014807650816,"quadratic_k_wad":1295240753826310656},"cma":{"library":"cma","seed":105,"population":16,"dimension":178,"initial_sigma":0.1,"CMA_diagonal_iterations":40,"start":"HA weights, W1[:,13:19] = 0 (start policy gives HA fees exactly)","generations":512,"train_seeds":[140000000,140131071],"train_markets_per_generation":256,"final_sigma":0.04966318892526065,"fitness":"mean replica edge minus T edge on the generation block (shared seeds)","proposals_rounded_to":1e-06,"monitor_seeds":[30000000,30002047],"monitor_every_minutes":5,"selection":"at each monitor point score the CMA mean and the best training proposal since the last point; keep the maximum monitor gain","selected":{"generation":465,"from":"mean","monitor_gain":1.7285938423048703,"monitor_se":0.02408296098809692}}},"port_zb64":"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","port_sha256":"243a04fe20939682a8ed127f07895fdf7dce610c30d9af0a6ea0b74a536202b9","notes":["All four input artifacts sha256-verified (HA 2801efc8, T 6ac5e013, RS2 port d845a4b9, replica e8a7a2af) and the HA code, T code, port and replica field hashes match HA input_sha256. Setup ran as given from test/scratch/amm-challenge; StarterStrategy validated.","Port: RS2 port extended with the toxicity anchor (T) and HA head; run inside the replica market code made parallel with numba prange. The port reproduced HA's own reported monitor score exactly at the start (1.1515186909 on seeds 30000000-30002047).","Gate B replica HA-over-T gain 1.127 (se 0.016) is near the low end of the 1.107-1.407 window; on holdout 40000000-40008191 HA-over-T is 1.117, and on real seeds 7004000-7004511 HA-over-T measured 1.082 (se 0.039).","Replica transfer held: frozen policy over HA predicted +0.564 (holdout) and measured +0.569 se 0.029 on the real engine; over T predicted +1.681, measured +1.650 se 0.046.","Gain over HA comes from retail edge (+0.53); arbitrage loss is slightly lower (+0.04).","Monitor curve was still rising at the end of search (1.70 at 46 min, 1.73 at 51 min, CMA sigma 0.053): resume from these weights with more generations; the next leg should consider larger training blocks (noise of 256-market blocks is ~0.05) and a decaying sigma.","Gas: afterSwap peak 234,741 (HA 231,604 on the same seeds), so roughly 10k gas headroom remains under 245,000.","The real-engine seeds 7000000-7000015 were used only for the pre-training gas probe; 7004000-7004511 were used once per arm (T, HA, frozen).","The gain needed for top 10 (about +3.1 over HA per the brief) is not reached: +0.57 over HA measured."]}