{ "approach": "Replace YQ's all-fill lambda EMA with the cumulative number of classified retail fills divided by timestamp+1, which includes empty elapsed steps. Classify a fill as retail if it is not first in its step, or if abs(pImplied-pHat)/pHat < sigmaHat/2 using the pre-update estimates. Store cumulative classified count in slot 11 and cumulative amountY in slot 12. Estimate mean amountY from those fills, then divide by current reserveY for the existing dimensionless flow-size term. Remove both original size EMA updates and elapsed size decay. Keep the remaining YQ fee/state logic unchanged; allow signed lambda coefficients and clamp the signed base fee at zero before the unchanged toxicity/skew layers. This is an estimate of observable classified-fill intensity, not an unbiased estimate of latent retail arrival rate: router censoring and first-fill misclassification remain. No claim is made to have removed that censoring. Grid: LAMBDA_COEF in {-12,12,24,36} bps and FLOW_SIZE_COEF in {0,4842,9684} bps. All 12 cells use the same 2,000 tuning seeds 10000..11999. Freeze the maximum tuning mean-difference candidate before opening seeds 400000..401999; apply no subsequent tuning. Do not promote this candidate; retain YQ as the network best. The code below is the best tested lambda-fix grid candidate, supplied for review, not a claimed improvement.", "tried": [ { "name": "L24_F9684", "lambda_coef_bps": 24, "flow_size_coef_bps": 9684, "code_sha256": "f9d20abd8d705cf01b73f782e6238e4faf64d4a1a9feda03e48253d916887260", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -1.2682646935585027, "se": 0.024083939162392296, "worst": [ { "seed": 11032, "diff": -4.81898905079413 }, { "seed": 11769, "diff": -4.70132036843529 }, { "seed": 11563, "diff": -4.630972953186074 }, { "seed": 10766, "diff": -4.589427022229984 }, { "seed": 10054, "diff": -4.4684364932325025 } ] }, "mean_edge": 520.9933521405762, "seconds_per_simulation": 0.10243918004981242 }, { "name": "L36_F0", "lambda_coef_bps": 36, "flow_size_coef_bps": 0, "code_sha256": "635a8415aa97262489a1917d6bf55c59031f0b867daa5e06500420a6868b44df", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -1.3130244567495033, "se": 0.023570964671591962, "worst": [ { "seed": 11563, "diff": -4.777914471684312 }, { "seed": 10054, "diff": -4.5291846952029005 }, { "seed": 10663, "diff": -4.428390136662415 }, { "seed": 10346, "diff": -4.3206324828844345 }, { "seed": 11653, "diff": -4.290218350341718 } ] }, "mean_edge": 520.9485923773852, "seconds_per_simulation": 0.10074628292839043 }, { "name": "L24_F4842", "lambda_coef_bps": 24, "flow_size_coef_bps": 4842, "code_sha256": "a12de4edad07c5576f89646bf522e57ab33b70b72e65c36e2286b5422b70266f", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -1.641902541195282, "se": 0.03248655897323635, "worst": [ { "seed": 10766, "diff": -6.32417611071935 }, { "seed": 11481, "diff": -5.955362705405605 }, { "seed": 11016, "diff": -5.861194841312226 }, { "seed": 11610, "diff": -5.530398755829879 }, { "seed": 10403, "diff": -5.4423900836019925 } ] }, "mean_edge": 520.6197142929394, "seconds_per_simulation": 0.10409548675036058 }, { "name": "L36_F4842", "lambda_coef_bps": 36, "flow_size_coef_bps": 4842, "code_sha256": "3bed08fc8f1b447a8177466a6ccaad01955c555e20e766c1d97a982b08cfb48a", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -1.750166017302459, "se": 0.029229846477934238, "worst": [ { "seed": 10054, "diff": -6.794395053747394 }, { "seed": 10986, "diff": -6.5044039423659115 }, { "seed": 10366, "diff": -6.395216831241328 }, { "seed": 10346, "diff": -5.801530171352965 }, { "seed": 10663, "diff": -5.748473118240099 } ] }, "mean_edge": 520.5114508168323, "seconds_per_simulation": 0.09766948784422129 }, { "name": "L36_F9684", "lambda_coef_bps": 36, "flow_size_coef_bps": 9684, "code_sha256": "63f37c238358a9e05f40a1e8a2299e81d4a7d059914ea54921d57196a267a5ae", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -2.450434438044513, "se": 0.0377640190007084, "worst": [ { "seed": 10366, "diff": -8.335690236774099 }, { "seed": 11284, "diff": -7.826833649691594 }, { "seed": 10986, "diff": -7.773315199509852 }, { "seed": 11729, "diff": -7.744395408323726 }, { "seed": 10524, "diff": -7.274364099258719 } ] }, "mean_edge": 519.8111823960902, "seconds_per_simulation": 0.096895755632082 }, { "name": "L24_F0", "lambda_coef_bps": 24, "flow_size_coef_bps": 0, "code_sha256": "049cf3c6545f262deaf80de5644f5e9169e68da1a514889a27d1b00863bdbbf5", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -2.9738728345465786, "se": 0.04504175228420288, "worst": [ { "seed": 10766, "diff": -9.338310206429924 }, { "seed": 10277, "diff": -8.44947748647104 }, { "seed": 11016, "diff": -8.352557442417265 }, { "seed": 11481, "diff": -8.303076968534526 }, { "seed": 11351, "diff": -8.024364307661244 } ] }, "mean_edge": 519.2877439995882, "seconds_per_simulation": 0.10681422876659781 }, { "name": "L12_F9684", "lambda_coef_bps": 12, "flow_size_coef_bps": 9684, "code_sha256": "adecfcafd9e4bde459d8587652115ed3939f3f45921015d3b08887354515550a", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -4.220797441153902, "se": 0.05189429940123246, "worst": [ { "seed": 10766, "diff": -11.55122331448888 }, { "seed": 11306, "diff": -10.16295574770993 }, { "seed": 11610, "diff": -10.01330470516558 }, { "seed": 11605, "diff": -10.004758337820078 }, { "seed": 11649, "diff": -9.881090912153581 } ] }, "mean_edge": 518.0408193929808, "seconds_per_simulation": 0.10810537262284196 }, { "name": "L12_F4842", "lambda_coef_bps": 12, "flow_size_coef_bps": 4842, "code_sha256": "f298c79dcf7d853b6d172464d0f4a39ca0180a87f12fabdecb82ad4758f8a2f9", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -8.007382829922621, "se": 0.061388019567443344, "worst": [ { "seed": 10766, "diff": -15.94012161093184 }, { "seed": 11016, "diff": -15.410289868777 }, { "seed": 11481, "diff": -15.007014322201258 }, { "seed": 10870, "diff": -14.76988630340611 }, { "seed": 11610, "diff": -14.422023772736509 } ] }, "mean_edge": 514.2542340042121, "seconds_per_simulation": 0.10966048660385422 }, { "name": "L12_F0", "lambda_coef_bps": 12, "flow_size_coef_bps": 0, "code_sha256": "87322291b245fcb40cf290e4b8df52458b8d8ec93284bb83c693849d1fc2bced", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -14.520826786182818, "se": 0.06218131274268038, "worst": [ { "seed": 11016, "diff": -23.01334814088881 }, { "seed": 10766, "diff": -22.541846663736976 }, { "seed": 11689, "diff": -22.0332926607868 }, { "seed": 11932, "diff": -21.6745291968561 }, { "seed": 11351, "diff": -21.62785073376017 } ] }, "mean_edge": 507.7407900479519, "seconds_per_simulation": 0.11331817684858106 }, { "name": "L-12_F9684", "lambda_coef_bps": -12, "flow_size_coef_bps": 9684, "code_sha256": "7d9bb107c2059bdcc59e34c8f4dec56b10cf7e127190ef16ce5f09f6ae354080", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -60.87448538257468, "se": 0.12687546171767738, "worst": [ { "seed": 11144, "diff": -83.42941818288159 }, { "seed": 11363, "diff": -80.31644575768212 }, { "seed": 10567, "diff": -79.81913445982809 }, { "seed": 10182, "diff": -78.84402146972377 }, { "seed": 10663, "diff": -78.77909814663417 } ] }, "mean_edge": 461.3871314515601, "seconds_per_simulation": 0.1263376701644156 }, { "name": "L-12_F4842", "lambda_coef_bps": -12, "flow_size_coef_bps": 4842, "code_sha256": "a0b46bdc79bfb1d775c5f50be8d6a526cf76783d934296d21ad4cafd0fe6a413", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -88.36030065583715, "se": 0.22079759380110958, "worst": [ { "seed": 10237, "diff": -116.18633701169801 }, { "seed": 11144, "diff": -115.69532014141669 }, { "seed": 10271, "diff": -114.39937380005131 }, { "seed": 10663, "diff": -114.07194299895548 }, { "seed": 11630, "diff": -113.92043157108765 } ] }, "mean_edge": 433.9013161782976, "seconds_per_simulation": 0.13377069656434468 }, { "name": "L-12_F0", "lambda_coef_bps": -12, "flow_size_coef_bps": 0, "code_sha256": "d5f9c4958b59d88fc2471b776d19e8c64c312379aba0013b3eceea99c3ec1a6b", "paired": { "n": 2000, "seed_start": 10000, "mean_diff": -92.4374890507777, "se": 0.20141282449516393, "worst": [ { "seed": 10237, "diff": -118.97709497877133 }, { "seed": 11144, "diff": -117.40922440286215 }, { "seed": 10271, "diff": -117.221612983706 }, { "seed": 10718, "diff": -116.29494590472405 }, { "seed": 11630, "diff": -116.26856515194243 } ] }, "mean_edge": 429.824127783357, "seconds_per_simulation": 0.13475494665256701 } ], "next": "Keep the promotion decision tied to the fresh paired result, not the 0..999 score.\nCalibrate the fill classifier and router censoring against labeled simulator trades on tuning seeds.\nIf revisiting this mechanism, jointly fit its intercept and shrinkage using a new tuning-only grid.", "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 // --- decay / update constants ---\n uint256 constant ELAPSED_CAP = 8;\n uint256 constant SIGNAL_THRESHOLD = WAD / 500; // ~20 bps of reserve\n uint256 constant DIR_DECAY = 800000000000000000; // 0.80\n uint256 constant ACT_DECAY = 700000000000000000; // 0.70\n uint256 constant SIZE_DECAY = 700000000000000000; // 0.70\n uint256 constant TOX_DECAY = 910000000000000000; // 0.91\n uint256 constant SIGMA_DECAY = 824000000000000000; // 0.824\n uint256 constant LAMBDA_DECAY = 990000000000000000; // 0.99\n uint256 constant SIZE_BLEND_DECAY = 818000000000000000; // 0.818\n uint256 constant TOX_BLEND_DECAY = 51000000000000000; // 0.051\n uint256 constant ACT_BLEND_DECAY = 985000000000000000; // 0.985\n uint256 constant PHAT_ALPHA = 260000000000000000; // 0.26\n uint256 constant PHAT_ALPHA_RETAIL = 50000000000000000; // 0.05\n uint256 constant DIR_IMPACT_MULT = 2;\n\n // --- Adaptive Shock Gate ---\n uint256 constant GATE_SIGMA_MULT = 10 * WAD;\n uint256 constant MIN_GATE = 30000000000000000; // 0.03 WAD\n\n // --- Cubic Toxicity ---\n uint256 constant TOX_CUBIC_COEF = 15000 * BPS;\n\n // --- Trade-Tox Boost ---\n uint256 constant TRADE_TOX_BOOST = 2500 * BPS;\n\n // --- Asymmetric Stale Dir ---\n uint256 constant STALE_ATTRACT_FRAC = 1124000000000000000; // 1.124\n\n // --- state caps ---\n uint256 constant RET_CAP = WAD / 10; // 10%\n uint256 constant TOX_CAP = WAD / 5; // 20%\n uint256 constant TRADE_RATIO_CAP = WAD / 5; // 20%\n uint256 constant LAMBDA_CAP = 5 * WAD; // max 5 trades/step estimate\n uint256 constant STEP_COUNT_CAP = 64; // guardrail\n\n // --- fee model constants ---\n uint256 constant BASE_FEE = 3 * BPS;\n uint256 constant SIGMA_COEF = 200000000000000000; // 0.20\n int256 constant LAMBDA_COEF = 24 * int256(BPS);\n uint256 constant FLOW_SIZE_COEF = 9684 * BPS;\n uint256 constant TOX_COEF = 250 * BPS;\n uint256 constant TOX_QUAD_COEF = 11700 * 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 = 500 * BPS;\n uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000; // 0.93\n uint256 constant TAIL_SLOPE_ATTRACT = 955000000000000000; // 0.955\n\n // slots[0] = bid fee\n // slots[1] = ask fee\n // slots[2] = last timestamp\n // slots[3] = dirState (centered at WAD, [0, 2*WAD])\n // slots[4] = actEma\n // slots[5] = pHat\n // slots[6] = sigmaHat\n // slots[7] = lambdaHat\n // slots[8] = mean classified-retail amountY / current reserveY\n // slots[9] = toxEma\n // slots[10] = stepTradeCount (raw integer)\n\n // slots[11] = cumulative classified-retail count\n // slots[12] = cumulative classified-retail amountY\n\n function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n slots[0] = BASE_FEE;\n slots[1] = BASE_FEE;\n slots[2] = 0;\n slots[3] = WAD; // neutral direction\n slots[4] = 0;\n slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n slots[6] = 950000000000000; // 0.095% initial sigma guess\n slots[7] = 800000000000000000; // 0.8 initial arrival-rate guess\n slots[8] = 2000000000000000; // 0.2% reserve-size ratio guess\n slots[9] = 0;\n slots[10] = 0;\n slots[11] = 0;\n slots[12] = 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];\n uint256 prevAskFee = slots[1];\n uint256 lastTs = slots[2];\n uint256 dirState = slots[3];\n uint256 actEma = slots[4];\n uint256 pHat = slots[5];\n uint256 sigmaHat = slots[6];\n uint256 lambdaHat = slots[7];\n uint256 sizeHat = slots[8];\n uint256 toxEma = slots[9];\n 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\n dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n\n\n stepTradeCount = 0;\n }\n\n bool firstInStep = stepTradeCount == 0;\n\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) {\n pImplied = spot;\n } else {\n pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma);\n }\n\n {\n uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n // Classify before updating pHat or sigmaHat.\n if (!firstInStep || ret < sigmaHat / 2) {\n slots[11] += 1;\n slots[12] += trade.amountY;\n }\n lambdaHat = (slots[11] * WAD) / (trade.timestamp + 1);\n if (lambdaHat > LAMBDA_CAP) lambdaHat = LAMBDA_CAP;\n sizeHat = slots[11] > 0 && trade.reserveY > 0\n ? wdiv(slots[12] / slots[11], trade.reserveY) : 0;\n if (sizeHat > WAD) sizeHat = WAD;\n uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n if (ret <= adaptiveGate) {\n pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha);\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 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\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\n actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n\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 int256 signedBase = int256(BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(FLOW_SIZE_COEF, flowSize)) + LAMBDA_COEF * int256(lambdaHat) / int256(WAD);\n uint256 fBase = signedBase > 0 ? uint256(signedBase) : 0;\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n\n fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));\n\n // Cubic toxicity\n {\n uint256 toxCubed = wmul(toxSignal, wmul(toxSignal, toxSignal));\n fMid = fMid + wmul(TOX_CUBIC_COEF, toxCubed);\n }\n\n uint256 dirDev;\n bool sellPressure;\n if (dirState >= WAD) {\n dirDev = dirState - WAD;\n sellPressure = true;\n } else {\n dirDev = WAD - dirState;\n sellPressure = false;\n }\n\n uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n\n uint256 bidFee;\n 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 // Directional protection using stale-price sign\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 // Trade-aligned toxicity boost\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) {\n bidFee = bidFee + tradeBoost;\n } else {\n askFee = askFee + tradeBoost;\n }\n }\n }\n\n // Asymmetric tail compression\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;\n slots[1] = askFee;\n slots[2] = trade.timestamp;\n slots[3] = dirState;\n slots[4] = actEma;\n slots[5] = pHat;\n slots[6] = sigmaHat;\n slots[7] = lambdaHat;\n slots[8] = sizeHat;\n slots[9] = toxEma;\n 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 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) {\n return WAD + wmul(centered - WAD, mul);\n }\n uint256 below = wmul(WAD - centered, mul);\n return below < WAD ? WAD - below : 0;\n }\n\n function getName() external pure override returns (string memory) {\n return \"lambda-fix-24-9684\";\n }\n}\n", "code_sha256": "f9d20abd8d705cf01b73f782e6238e4faf64d4a1a9feda03e48253d916887260", "delta": "Python: let s be YQ.splitlines(keepends=True). Apply (start,end,text) splices below in reverse order as s[start:end]=text.splitlines(keepends=True), then join s. Indices are zero-based against original YQ. [[46,48,\" int256 constant LAMBDA_COEF = 24 * int256(BPS);\\n uint256 constant FLOW_SIZE_COEF = 9684 * BPS;\\n\"],[67,68,\" // slots[8] = mean classified-retail amountY / current reserveY\\n\"],[70,70,\"\\n // slots[11] = cumulative classified-retail count\\n // slots[12] = cumulative classified-retail amountY\\n\"],[83,83,\" slots[11] = 0;\\n slots[12] = 0;\\n\"],[106,107,\"\"],[109,114,\"\"],[134,134,\" // Classify before updating pHat or sigmaHat.\\n if (!firstInStep || ret < sigmaHat / 2) {\\n slots[11] += 1;\\n slots[12] += trade.amountY;\\n }\\n lambdaHat = (slots[11] * WAD) / (trade.timestamp + 1);\\n if (lambdaHat > LAMBDA_CAP) lambdaHat = LAMBDA_CAP;\\n sizeHat = slots[11] > 0 && trade.reserveY > 0\\n ? wdiv(slots[12] / slots[11], trade.reserveY) : 0;\\n if (sizeHat > WAD) sizeHat = WAD;\\n\"],[162,164,\"\"],[175,176,\" int256 signedBase = int256(BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(FLOW_SIZE_COEF, flowSize)) + LAMBDA_COEF * int256(lambdaHat) / int256(WAD);\\n uint256 fBase = signedBase > 0 ? uint256(signedBase) : 0;\\n\"],[282,283,\" return \\\"lambda-fix-24-9684\\\";\\n\"]]", "score": { "n": 1000, "mean_edge": 523.3465505296584, "se": 2.781615080594578, "seed_start": 0 }, "paired": { "reference": "YQ 00fae418", "n": 2000, "seed_start": 400000, "mean_diff": -1.267292407417586, "se": 0.02337966684501943, "worst": [ { "seed": 401613, "diff": -5.9984137996274285 }, { "seed": 400375, "diff": -4.9381241819625075 }, { "seed": 400073, "diff": -4.449297534598941 }, { "seed": 401111, "diff": -4.383229457060452 }, { "seed": 400500, "diff": -4.279268768960833 } ] }, "paired_evidence": { "seed_start": 400000, "n": 2000, "encoding": "base64 of zlib-compressed little-endian IEEE-754 float64 differences, one per ascending seed; candidate minus YQ", "uncompressed_sha256": "95eb878220a4bd6a56bc08e3a28d22cda71b9ec832807cc4231a9d4254feb500", "data": "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", "decode_python": "struct.unpack('<2000d', zlib.decompress(base64.b64decode(data)))" }, "seconds_per_simulation": 0.10034779807599262, "validate_ok": true, "blocked": null, "citations": [ { "url": "https://raw.githubusercontent.com/jiayaoqijia/amm-challenge-yq/3e9dc7d5a6192c88b562a0f8d9c172ca566ec94d/contracts/src/Strategy.sol", "supports": "Exact YQ parent code, all-print arrival estimator and reserve-ratio size EMA; downloaded SHA-256 checked against the brief." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/README.md", "supports": "Challenge mechanics, 10,000 steps and fixed 30 bps normalizer." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/config.py", "supports": "Canonical simulation parameters and randomized ranges." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/match.py", "supports": "Seed-specific NumPy parameter draws in order: mean retail size, arrival rate, GBM sigma; explicit identical configs on both sides." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/simulation/engine.rs", "supports": "Arbitrage before retail, zero-based step timestamps and per-trade edge accounting." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/evm/strategy.rs", "supports": "Rust EVM initialization and swap calls use a 250,000 gas limit." }, { "url": "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/AMMStrategyBase.sol", "supports": "32-slot state array and 10% fee clamp." }, { "url": "https://www.linkedin.com/pulse/amm-fee-challenge-notes-from-our-run-optimization-arena-qe3ff", "supports": "Algebra first-party write-up: asymmetric fees, long-run state estimates, first-trade-only arbitrage and large simulation batches. It does not establish the brief's claim about arrival rate explaining most variance." }, { "url": "https://raw.githubusercontent.com/dipankar/amm-challenge/main/ANALYSIS.md", "supports": "Public research post-mortem advocating latent fair-price/state estimation; its performance claims were not independently reproduced here." } ], "promoted": false, "tuning_variance_diagnostic": { "reference": "YQ", "n": 2000, "seed_start": 10000, "statistic": "Univariate OLS R-squared with an intercept; equivalently squared Pearson correlation.", "r_squared": { "mean_retail_size": 0.05214759161503556, "retail_arrival_rate": 0.6906851943644833, "gbm_sigma": 0.002194463969107986 }, "interpretation": "Descriptive association with edge on tuning seeds. This does not establish the optimal sign of a fee coefficient or validate an arrival-rate estimator." }, "promotions": [], "scoreboard": { "reference": "YQ", "reference_sha256": "00fae418c49cd681ad0879c6f96ebed0163fab5a660b38030f11e6947a39afd4", "reference_tuning_score": { "n": 2000, "seed_start": 10000, "mean_edge": 522.2616168341347, "se": 2.030971562149171 }, "best_tuning_variant": "L24_F9684", "best_tuning_sha256": "f9d20abd8d705cf01b73f782e6238e4faf64d4a1a9feda03e48253d916887260", "retained_network_best_sha256": "00fae418c49cd681ad0879c6f96ebed0163fab5a660b38030f11e6947a39afd4" }, "validation": { "final_cli_output": "Validating strategy...\nCompiling strategy...\nStrategy 'lambda-fix-24-9684' validated successfully!", "evm_direct_checks": { "name": "L24_F9684", "code_sha256": "f9d20abd8d705cf01b73f782e6238e4faf64d4a1a9feda03e48253d916887260", "ok": true, "calls": 1003, "init_gas": 189944, "max_observed_swap_gas": 130717, "slots": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ] }, "all_grid_variants_checked": 12, "gas_note": "Observed gas from pyrevm execution results, not the executor wrapper's approximate gas field; each test call was limited to 250000 gas. Not a proof over arbitrary uint256 inputs.", "reconstruction_delta_exact": true, "delta_characters": 1442 }, "measurement": { "simulator_commit": "6b6921f8d463314aa7c96234e1be25a25245f704", "requested_budget_seconds": 3600, "elapsed_seconds_since_first_clock": 3727.134967, "simulation_steps": 10000, "normalizer_fee_bps": 30, "workers": 8, "paired_definition": "Each strategy independently competes with VanillaStrategy at fixed 30 bps using identical per-seed parameters and Rust RNG seeds. Difference = candidate edge minus YQ edge.", "se_definition": "Sample standard deviation of per-seed observations (ddof=1), divided by sqrt(n); paired SE uses differences, not independent-score errors.", "timing_definition": "Wall seconds inside Rust run_batch divided by simulations, amortized across 8 workers; final candidate holdout without chart-history recording. Excludes compilation and configuration construction.", "tuning_acceleration": "Scratch-only optional branch skips chart-history capture and average-fee reporting; market, EVM, random draws and edge accounting are unchanged. YQ tuning reference used the original build. Candidate tuning, holdout and score omit chart history. The omitted capture_step function only reads market state after edge accumulation.", "acceleration_parity": [ { "name": "YQ", "code_sha256": "00fae418c49cd681ad0879c6f96ebed0163fab5a660b38030f11e6947a39afd4", "n": 32, "seed_start": 10000, "identical": true, "full_seconds": 6.4907188708893955, "no_history_seconds": 6.459459614939988 }, { "name": "L-12_F0", "code_sha256": "d5f9c4958b59d88fc2471b776d19e8c64c312379aba0013b3eceea99c3ec1a6b", "n": 32, "seed_start": 10000, "identical": true, "full_seconds": 10.363515398930758, "no_history_seconds": 7.036363726016134 }, { "name": "L24_F4842", "code_sha256": "a12de4edad07c5576f89646bf522e57ab33b70b72e65c36e2286b5422b70266f", "n": 32, "seed_start": 10000, "identical": true, "full_seconds": 5.004852497018874, "no_history_seconds": 8.365151005797088 }, { "name": "L36_F9684", "code_sha256": "63f37c238358a9e05f40a1e8a2299e81d4a7d059914ea54921d57196a267a5ae", "n": 32, "seed_start": 10000, "identical": true, "full_seconds": 6.866948869079351, "no_history_seconds": 7.972078763879836 } ], "forbidden_seeds_used": false, "validation_data_used_for_selection": false, "starter_comparison": "Not run in this bounded round-2 item; required paired reference is YQ.", "public_variance_claim": "Searched for but did not locate the specific public claim that arrival rate explains most cross-simulation variance. Do not treat that claim as verified." } }