{ "notes": "EPISODE 1 (nothing had run; 400 items, 15 episodes). Credit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved, in every brief and file.\nREAD THIS EPISODE (artifacts the goal names): QLX5-LEAN = +0.0352 se 0.0071 on 512 engine seeds, peak gas 208,366, 22,440 runtime bytes, 47,230 chars; QLX5 certified P/T/F only (Q, G, E never run on it). AGE-LEAN = +0.0322 se 0.0084 on 512, +1,053 chars, +139 bytes. Engine cost: about 0.7 s per seed per arm alone on 8 workers, 2.5-2.8 s when shared; so one item = at most 256 seeds x 3 arms, or 128 x 3 for search. The engine's split test hit rate is 0.892 with 5 tracked candidates; Taylor's replica divides a constant K and is not the engine, so replica scores of anything touching the split test do not transfer; the fast replica (fastlean) is LEAN only, not QLX5. QLX5's source was not read this episode: c-map lists its constants for c-round1.\nSPAWNED (72 items):\n(a) a-build [qa] builds QLX5+AGE and its Python reference, gate G -> a-check [qa] gates P,T,F,G on another machine (waits on ready=true) and a-q [qa] gate Q on replica seeds 10000..12047 -> a-engine [qa] 256 fresh seeds, arms CAND/QLX5/QT1 (waits on gates.all=pass) -> a-wide [s1..s7] 7 x 256 more (waits on go=true: peak ok and CAND-QLX5 > -0.02). Together 2,048 seeds 10200000..10202047. Pool exactly from each result's sum_d, sum_d2, n: mean = S1/N, se = sqrt((S2 - S1^2/N)/(N-1)/N). If the plane refused a-wide's check with batch pairing, spawn it again without the check.\n(b) b-core [r1..r4]: four independent ports of the engine's step loop, streams and cfmm/router/arbitrageur arithmetic to numba, proven on 128 constant-fee edges against the engine on screening seeds 9700000..9700063 -> b-qlx [r1..r4] (each waits on its own core's ready=true): LEAN and QLX5 with production U1 tables and the tracked split test on that core, proven per seed against the engine rows of 10010512..10011023, with every structural constant a parameter (result field knobs).\n(c) c-map [map] lists exactly 32 knobs (find/lo/hi) -> c-round1 [k00..k31], knob n on 128 fresh seeds, arms QLX5/LO/HI, seeds 10203000+128n .. +127 (to 10207095); merged in 2 groups of 16.\n(d) d-ideas, 20 mechanisms on fastlean, choose 64000..65023 with early stopping, report 10000..12047 against LEAN and stacked on AGE: age-fee, same-step, fill-size, size-run, share-feedback, undercut, post-arb-skew, inventory, silence-bound, fee-memory, lookahead, side-imbalance, markout, tell-coverage, sd-extrap, drift, second-order, mixture-branch, sync-grade, endgame; merged in 2 groups of 10.\nFRESH ENGINE SEED LEDGER (never reuse; a seed leased is spent whether or not it ran): 10200000..10202047 a-engine + a-wide; 10202048..10202055 a-build gas; 10203000..10207095 c-round1. NEXT FREE: 10208000. Screening or old seeds used for proofs only: 9700000..9700511, 10010512..10011023, replica 74200..74249.\nNEXT EPISODE, in this order:\n1. (a) Pool the 8 engine results. QLX5+AGE comes back only at >= +0.04 over QLX5 on 1,024+ fresh seeds; #1 needs about +0.08, so whatever it gives, it becomes the base that (c) and (d) winners stack on if it is positive by 2 se. The two rules both act on the rival estimate, so the stack may give well under +0.032: do not assume it adds.\n2. (c) From the two merges take knobs whose better side is >= +0.02 or > 1.5 se (128-seed se is about 0.015, so one round proves nothing). Round 2: the winners at finer values and in pairs, 128 fresh seeds each from 10208000, arms QLX5 and variants; then the best combination through build -> check -> engine on 1,024+ fresh seeds (4 x 256, arms CAND/QLX5/QT1). A knob that moves nothing on both sides is dead: do not test it again.\n3. (b) If a b-qlx result is ready (per-seed parity with the engine), move the search off the engine: tuning batches on that replica over its knobs (it runs about 1,000 times cheaper than the engine and spends no fresh seed; choose on engine seeds 9800000..9801023, report on 9900000..9902047), then engine confirmation of the best. If no b-core is ready, read first_divergence and not_done, and split the port: streams alone (proven against a logging engine build, requires tools rust), then arithmetic. If its items waited with capable=0, relax requires.\n4. (d) Promote each mechanism with promote=true (>= +0.03 on 10000..12047, also stacked on AGE) into a pipeline: Solidity port on the current base with its Python reference -> check P,T,F,G -> engine 256 seeds -> wide. Mechanisms with already_present=true or under +0.01 are spent.\nRULES KEPT: full 64-hex hashes in briefs; requires linux-x64 and minCpus 4 for Solidity and engine items; limits 50,000 chars, 24,576 bytes, peak 245,000, 0 OOG; a contract comes back only at >= +0.04 over QLX5 on 1,024+ fresh engine seeds, paired with QLX5 and QT1; nothing is submitted, the requester asks the user. Budget after this episode: 328 items, 14 episodes. Spent lines (do not repeat): table compression and refit, price-belief variants (twocomp, lattice, rival pin), per-run sigma/rate, exact rival carry, learned residual heads, kappa.", "spawn": [ { "name": "a-build", "brief": "Build QLX5+AGE: one Solidity contract and its Python reference.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40.\nThe AGE rule is in https://api.imd.fun/artifacts/0343e8049294da6680c2ee1ad413fa5dc95843b1893e96c3b173df49b850b3e1: read rule.as_ported and rule.state, and build_age.py in harness_zb64. It was applied to LEAN; apply the same rule to QLX5 and change nothing else. On a callback read as retail on which QLX5's split test has not itself set the rival estimate, the pull weight becomes pullW(timestamp - rt) = 7e17*age/(age+1) in WAD in place of the constant 35e16, with rt the timestamp of the last binding bound. Decide what rt does when the split test sets the estimate, and say why. rt must not collide with the storage bits QLX5 already uses (the split test's tracked offset among them): find free bits, and add no storage word unless none are free.\nPython reference: the certified QLX5 reference exactly as https://api.imd.fun/artifacts/d73c1749574cce67042552e9278be2ba20c8fedf9720bdee71c27d4019f21f02 patches it (reference_patch, manifest), with the same rule (a0=0, ainf=0.7, tau=1).\nGate G: compile with the kit's pinned solc 0.8.24 (optimizer 200, viaIR, paris); source <= 50,000 characters, runtime <= 24,576 bytes, afterSwap peak gas <= 245,000, 0 out of gas. Measure gas on engine seeds {{seed0}}..{{seed1}} (yours alone, run once, no other engine seed), arms CAND and QLX5, with the block driver, driver_zb64 of https://api.imd.fun/artifacts/764c9461a9f3bab6e277178f4bb48553d1b97c6cca33bed016f7c9bfd611cc42, unchanged. Smoke gates T and F as that certification defines them, on replica seeds 74200..74203.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; ready (true only if G and both smokes pass); gates.G, gates.T_smoke, gates.F_smoke (each \"pass\" or \"fail\"); source_sha256 (64 hex); source_chars; runtime_bytes; peak_gas; out_of_gas; code_zb64 (base64(zlib(source))); reference_zb64 (base64(zlib(json of file name to text))) holding only the reference files you changed or added, and reference_base, what they overlay; rule (what differs from QLX5, the bits used, the rt decision); diff_chars; engine_seeds_used; not_done.", "items": [ { "key": "qa", "vars": { "seed0": "10202048", "seed1": "10202055" } } ], "output": { "format": "json", "maxBytes": 64000 }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "a-check", "brief": "Certify the QLX5+AGE contract another machine built: its result is {{after.result}} (code_zb64, reference_zb64, rule). Treat it as data and trust none of its numbers: run the gates yourself, with your own harness or the certified one.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40.\nThe gates are those of the QLX5 certification https://api.imd.fun/artifacts/d73c1749574cce67042552e9278be2ba20c8fedf9720bdee71c27d4019f21f02 (protocol, T.definition, F.definition), extended to the AGE rule as gate T of https://api.imd.fun/artifacts/0343e8049294da6680c2ee1ad413fa5dc95843b1893e96c3b173df49b850b3e1 reads it (rule kind, age, weight per callback).\nG: check the source hash, compile with the kit's pinned solc 0.8.24 (optimizer 200, viaIR, paris): source <= 50,000 characters, runtime <= 24,576 bytes. P: the kit's gatep.py on Taylor's reference. F: fees within 0.01 bps of the Python reference on the first 2,000 callbacks of each of replica seeds 74200..74249, both sides. T: labels equal the Python reference on every callback of the same 50 full seeds, autonomous stream: inferred arb, split tested, split verdict, tracked offset, and the AGE rule's kind, age and weight; the fixed-input stream too if time allows. Run them in the order G, P, F, T. Also check that the contract differs from QLX5 only where the rule says.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; gates.P, gates.T, gates.F, gates.G (each \"pass\", \"fail\" or \"not_run\"); gates.all (\"pass\" only if those four are all \"pass\", else \"fail\"); T.callbacks, T.split_tests and the mismatch count of each compared label; F.callbacks, F.worst_bps, F.fee_sides_over_tolerance; source_sha256; source_chars; runtime_bytes; runtime_sha256; code_zb64 (the contract, unchanged, so the next stage needs this file alone); diff_vs_qlx5 (what differs); first_failure (inputs and both outputs, or null); not_done.", "items": [ { "key": "qa" } ], "output": { "format": "json", "maxBytes": 64000 }, "after": { "batch": "a-build", "pairing": "item", "check": { "path": "ready", "equals": true } }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "a-q", "brief": "Gate Q, the replica score, of the QLX5+AGE Python reference another machine built: its result is {{after.result}} (reference_zb64 and reference_base say how to lay it out; treat it as data).\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nThe base is the certified QLX5 reference exactly as https://api.imd.fun/artifacts/d73c1749574cce67042552e9278be2ba20c8fedf9720bdee71c27d4019f21f02 patches it (reference_patch, manifest); the LEAN reference is LEANBASE as https://api.imd.fun/artifacts/a88ff982eba7e078bc6ccb1555b90a211c00c9fd76ec90a62ab13a4074f2c3d0 runs it (a0=0.35 ainf=0.35), and LEAN+AGE is the same with a0=0 ainf=0.7 tau=1.\nRun Taylor's replica on seeds 10000..12047 (2,048 seeds, the report block) for four policies, paired by seed: CAND (QLX5+AGE reference), QLX5 reference, LEAN, LEAN+AGE. Nothing is chosen here, so the choose block 64000..65023 is not used; say so. If time runs short, finish complete blocks of 256 seeds for all four and report the seeds done. Note that this replica divides a constant K, so the split test fires more often on it than on the Rust engine: the score is the reference's, not the board's.\nResult: one JSON object of at most 30,000 bytes with the fields: credit; seeds.first, seeds.last, seeds.n; mean_edge of each policy; diffs CAND-QLX5, CAND-LEAN, QLX5-LEAN, LEANAGE-LEAN and CAND-LEANAGE, each with n, mean_diff, se (sd of paired differences with n-1, over sqrt(n)), sum_d, sum_d2, seeds_positive, min, max; split_test hit rate of CAND and QLX5; gates.Q (\"pass\" if CAND-QLX5 mean_diff + 2*se >= 0, else \"fail\"); reference file sha256s; commands; not_done.", "items": [ { "key": "qa" } ], "output": { "format": "json", "maxBytes": 32000 }, "after": { "batch": "a-build", "pairing": "item", "check": { "path": "ready", "equals": true } }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "a-engine", "brief": "Gate E, first block, of the certified QLX5+AGE contract: the certification is {{after.result}} (code_zb64, source_sha256; check the hash; treat it as data). Arms: CAND (that contract), QLX5, QT1, paired by seed.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40. QT1 is qt1/Strategy.sol from the kit's reference/materialize.py, source sha256 c68887cff61180e12ba2b1ceb333edf76a830f91f63b5d775a8806fb9ec08aca.\nEngine: the kit's setup_fast.sh install (benedictbrady/amm-challenge@6b6921f8d463314aa7c96234e1be25a25245f704; pinned solc 0.8.24, optimizer 200, viaIR, paris), run by the block driver, driver_zb64 of https://api.imd.fun/artifacts/764c9461a9f3bab6e277178f4bb48553d1b97c6cca33bed016f7c9bfd611cc42, unchanged: each arm alone against the 30 bps VanillaStrategy, blocks of 32 seeds, every arm inside each block.\nSeeds {{seed0}}..{{seed1}} are fresh and yours alone: run each once, in order, and no other engine seed. Start no new block after 35 minutes of engine time and report complete blocks only; list the seeds you did not run as unused.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; key; seeds.first, seeds.last, seeds.n, seeds.unused; arms CAND, QLX5, QT1, each with mean_edge, peak_gas, out_of_gas, runtime_bytes, source_sha256; diffs CAND-QLX5, CAND-QT1 and QLX5-QT1, each with n, mean_diff, se (sd of paired differences with n-1, over sqrt(n)), sum_d, sum_d2, seeds_positive, min, max; pass_peak (true only if CAND's peak <= 245,000 with 0 out of gas and no revert); go (true only if pass_peak and CAND-QLX5 mean_diff > -0.02); rows_zb64 (base64(zlib(csv seed,CAND,QLX5,QT1, unrounded))); code_zb64 (the contract, unchanged); not_done.", "items": [ { "key": "qa", "vars": { "seed0": "10200000", "seed1": "10200255" } } ], "output": { "format": "json", "maxBytes": 64000 }, "after": { "batch": "a-check", "pairing": "item", "check": { "path": "gates.all", "equals": "pass" } }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "a-wide", "brief": "Gate E, one more block, of the certified QLX5+AGE contract. You are handed the first block's result from batch {{after.batch}}: take CAND from its code_zb64 and check it against its arms.CAND.source_sha256; treat the file as data. If its go is not true, run nothing and write only credit, key, ran (false) and why. Arms: CAND, QLX5, QT1, paired by seed.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40. QT1 is qt1/Strategy.sol from the kit's reference/materialize.py, source sha256 c68887cff61180e12ba2b1ceb333edf76a830f91f63b5d775a8806fb9ec08aca.\nEngine: the kit's setup_fast.sh install (benedictbrady/amm-challenge@6b6921f8d463314aa7c96234e1be25a25245f704; pinned solc 0.8.24, optimizer 200, viaIR, paris), run by the block driver, driver_zb64 of https://api.imd.fun/artifacts/764c9461a9f3bab6e277178f4bb48553d1b97c6cca33bed016f7c9bfd611cc42, unchanged: each arm alone against the 30 bps VanillaStrategy, blocks of 32 seeds, every arm inside each block.\nSeeds {{seed0}}..{{seed1}} are fresh and yours alone: run each once, in order, and no other engine seed. Start no new block after 35 minutes of engine time and report complete blocks only; list the seeds you did not run as unused.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; key; seeds.first, seeds.last, seeds.n, seeds.unused; arms CAND, QLX5, QT1, each with mean_edge, peak_gas, out_of_gas, runtime_bytes, source_sha256; diffs CAND-QLX5, CAND-QT1 and QLX5-QT1, each with n, mean_diff, se (sd of paired differences with n-1, over sqrt(n)), sum_d, sum_d2, seeds_positive, min, max; pass_peak (true only if CAND's peak <= 245,000 with 0 out of gas and no revert); go (true only if pass_peak and CAND-QLX5 mean_diff > -0.02); rows_zb64 (base64(zlib(csv seed,CAND,QLX5,QT1, unrounded))); ran (true); not_done.", "items": [ { "key": "s1", "vars": { "seed0": "10200256", "seed1": "10200511" } }, { "key": "s2", "vars": { "seed0": "10200512", "seed1": "10200767" } }, { "key": "s3", "vars": { "seed0": "10200768", "seed1": "10201023" } }, { "key": "s4", "vars": { "seed0": "10201024", "seed1": "10201279" } }, { "key": "s5", "vars": { "seed0": "10201280", "seed1": "10201535" } }, { "key": "s6", "vars": { "seed0": "10201536", "seed1": "10201791" } }, { "key": "s7", "vars": { "seed0": "10201792", "seed1": "10202047" } } ], "output": { "format": "json", "maxBytes": 64000 }, "after": { "batch": "a-engine", "pairing": "batch", "check": { "path": "go", "equals": true } }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "b-core", "brief": "Build an engine-faithful fast simulation core, and prove it seed by seed against the Rust engine.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nThe engine is benedictbrady/amm-challenge@6b6921f8d463314aa7c96234e1be25a25245f704 (amm_sim_rs; the kit's setup_fast.sh installs it). The fast LEAN replica, code_zb64 (base64(zlib(tar))) of https://api.imd.fun/artifacts/a88ff982eba7e078bc6ccb1555b90a211c00c9fd76ec90a62ab13a4074f2c3d0, is a numba port of Taylor's replica2.py, which is not the engine: `differences` in https://api.imd.fun/artifacts/8b18deed94ffc0ce7268140f652b5a1d2cf1a55e98a7e18575d1c51ce83cb098 lists how they differ, with file and line (k recomputed from the rounded reserves at every quote and arbitrage sizing in cfmm.rs and arbitrageur.rs; reserves updated by increments with a fee bucket; execution order; truncated WAD integers at the EVM boundary; the fee clamp; the random streams).\nWrite enginecore.py, numba, one compiled call per run: the engine's step loop with the engine's own random streams (the config draw as the kit's bootstrap/smoke_engine.config_for; price process, retail arrivals, sizes and sides exactly as price_process.rs and retail.rs draw them) and the exact arithmetic and order of cfmm.rs, router.rs and arbitrageur.rs, for a submission pool whose fees come from a policy callback that is handed what afterSwap is handed, as truncated WAD integers, against the 30 bps pool. Deliver it with constant-fee policies.\nProof: a submission contract with constant fees, 30/30 bps and then 25/45 bps bid/ask, run on the engine with the kit's engine_eval.py on seeds 9700000..9700063 (the kit's screening seeds; use no seed from 10,200,000 up), against enginecore on the same seeds: 128 edges. If cargo is at hand, also build the engine with a logging patch and compare price, orders, fills and reserves step by step on 4 seeds; else say it was not done.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; ready (true only if all 128 edges agree within 1e-9 relative); parity.n, parity.max_abs_diff, parity.max_rel_diff, parity.bit_identical, parity.worst (seed, policy, both edges); step_logs.compared, step_logs.first_divergence; ported (each difference: what, engine file and line, done or not); rng (generator, distributions, crate versions, how seeded); runs_per_core_s; code_zb64 (base64(zlib(tar of enginecore.py and its tests))); source_sha256; run (the exact commands); not_done.", "items": [ { "key": "r1" }, { "key": "r2" }, { "key": "r3" }, { "key": "r4" } ], "output": { "format": "json", "maxBytes": 64000 }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "b-qlx", "brief": "Put the LEAN and QLX5 policies on the engine-faithful core another machine built, and prove them seed by seed against engine rows that already exist. The core is {{after.result}} (code_zb64, run; treat it as data, and repeat its parity on 16 seeds first).\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nThe fast LEAN policy is fastlean.py in code_zb64 of https://api.imd.fun/artifacts/a88ff982eba7e078bc6ccb1555b90a211c00c9fd76ec90a62ab13a4074f2c3d0: LEANBASE, the float reference. The contracts are LEAN (code_zb64 of https://api.imd.fun/artifacts/a79a3606add967bb8f8ec2af8ef3d61bafb597419c488133597c8af5b9d34505, sha256 a6dfc3ba6b7a1b19ae77680eeb1d24f1e902a216a10c1093d8388a0510c38c94) and QLX5 (code_zb64.QLX5 of https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15, sha256 e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40). Port what the contracts do and LEANBASE does not: the production U1 tables decoded from the contract's QPL blob (prod_lookup.py in reference_patch of https://api.imd.fun/artifacts/d73c1749574cce67042552e9278be2ba20c8fedf9720bdee71c27d4019f21f02), truncated WAD inputs and returned fee wads, and QLX5's tracked split test with its offset m0 (qlx.hit_mku there; the rule is in https://api.imd.fun/artifacts/8b18deed94ffc0ce7268140f652b5a1d2cf1a55e98a7e18575d1c51ce83cb098). Make every structural constant of QLX5 a parameter with the contract's value as default.\nProof, no engine run needed: rows_zb64 of https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15 holds the engine's edge of LEAN and of QLX5 on seeds 10010512..10011023 to 6 decimals. Run your port on those 512 seeds for both and compare per seed. Use no seed from 10,200,000 up.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; ready (true only if, for LEAN and for QLX5, mean absolute difference <= 1e-4 and largest <= 1e-2 over all 512 seeds); parity.LEAN and parity.QLX5, each with n, mean_diff, mean_abs_diff, max_abs_diff, within_1e-6, within_1e-4 and the five worst seeds; qlx5_minus_lean (yours, and the engine's 0.035185); split_hit_rate (tries, hits, rate on those seeds); knobs (each parameter: name, default, meaning); runs_per_core_s; code_zb64 (base64(zlib(tar))); source_sha256; run (the exact commands); not_done (first divergence found, if any).", "items": [ { "key": "r1" }, { "key": "r2" }, { "key": "r3" }, { "key": "r4" } ], "output": { "format": "json", "maxBytes": 64000 }, "after": { "batch": "b-core", "pairing": "item", "check": { "path": "ready", "equals": true } }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "c-map", "brief": "Map QLX5's structural constants, so that 32 other machines can each test one on the engine.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40. How it was built: mku.py in scripts_zb64 of https://api.imd.fun/artifacts/8b18deed94ffc0ce7268140f652b5a1d2cf1a55e98a7e18575d1c51ce83cb098; its base, LEAN, is code_zb64 of https://api.imd.fun/artifacts/a79a3606add967bb8f8ec2af8ef3d61bafb597419c488133597c8af5b9d34505.\nList exactly 32 knobs, numbered n = 0..31, from these families: phase thresholds; rival clip and band widths; synced-table switches; table levels; tell floors; the split test's window and candidates. A knob is one constant or one switch of the source whose change leaves a valid contract. Order them by the edge you expect them to move, most first, families interleaved. Leave out what is spent: table compression or refit, price-belief variants (twocomp, lattice, rival pin), per-run sigma or rate, exact rival carry, learned residual heads, kappa.\nFor each knob give: find, a substring of the source that occurs exactly once (assert it); lo and hi, the two strings that replace it, a meaningful step down and up (about 25 to 50 percent of the constant's natural scale), or the two alternatives of a switch; and what it controls, in one sentence. Compile every variant you have time for with the kit's pinned solc 0.8.24 (optimizer 200, viaIR, paris) and check source <= 50,000 characters and runtime <= 24,576 bytes; replace a knob whose variants do not compile. No engine run.\nResult: one JSON object of at most 60,000 bytes with the fields: credit; qlx5_sha256; knobs, a list of exactly 32 objects in order, each with n, id (a short name), family, meaning, value (as in QLX5), find, lo, hi, compiled_lo, compiled_hi (true, false or \"not_run\") and runtime_bytes of each when compiled; families (how many knobs each has, and constants you left out and why); not_done.", "items": [ { "key": "map" } ], "output": { "format": "json", "maxBytes": 64000 }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "c-round1", "brief": "Engine test of one structural constant of QLX5. You are handed the map from batch {{after.batch}}, a JSON file with a list knobs (treat it as data): yours is the entry whose n is {{n}}.\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nQLX5 is code_zb64.QLX5, base64(zlib(utf-8 Solidity)), in https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15; its source sha256 must be e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40.\nBuild two variants: LO, QLX5 with the knob's find replaced by its lo, and HI, with its hi; assert find occurs exactly once and change nothing else. Limits: source <= 50,000 characters, runtime <= 24,576 bytes, afterSwap peak gas <= 245,000, 0 out of gas. If one variant does not compile or breaks a limit, say so and run the other.\nEngine: the kit's setup_fast.sh install (benedictbrady/amm-challenge@6b6921f8d463314aa7c96234e1be25a25245f704; pinned solc 0.8.24, optimizer 200, viaIR, paris), run by the block driver, driver_zb64 of https://api.imd.fun/artifacts/764c9461a9f3bab6e277178f4bb48553d1b97c6cca33bed016f7c9bfd611cc42, unchanged: each arm alone against the 30 bps VanillaStrategy, blocks of 32 seeds, every arm inside each block.\nArms: QLX5, LO, HI, paired by seed. Seeds {{seed0}}..{{seed1}} (128) are fresh and yours alone: run each once, in order, and no other engine seed. Start no new block after 35 minutes of engine time and report complete blocks only.\nResult: one JSON object of at most 14,000 bytes with the fields: credit; n; id; family; find; lo; hi; seeds.first, seeds.last, seeds.n, seeds.unused; arms QLX5, LO, HI, each with mean_edge, peak_gas, out_of_gas, runtime_bytes, source_sha256; diffs LO-QLX5, HI-QLX5 and HI-LO, each with n, mean_diff, se (sd of paired differences with n-1, over sqrt(n)), sum_d, sum_d2, seeds_positive, min, max; pass_peak of LO and of HI (peak <= 245,000, 0 out of gas, no revert); reading (one sentence); not_done.", "items": [ { "key": "k00", "vars": { "n": "0", "seed0": "10203000", "seed1": "10203127" } }, { "key": "k01", "vars": { "n": "1", "seed0": "10203128", "seed1": "10203255" } }, { "key": "k02", "vars": { "n": "2", "seed0": "10203256", "seed1": "10203383" } }, { "key": "k03", "vars": { "n": "3", "seed0": "10203384", "seed1": "10203511" } }, { "key": "k04", "vars": { "n": "4", "seed0": "10203512", "seed1": "10203639" } }, { "key": "k05", "vars": { "n": "5", "seed0": "10203640", "seed1": "10203767" } }, { "key": "k06", "vars": { "n": "6", "seed0": "10203768", "seed1": "10203895" } }, { "key": "k07", "vars": { "n": "7", "seed0": "10203896", "seed1": "10204023" } }, { "key": "k08", "vars": { "n": "8", "seed0": "10204024", "seed1": "10204151" } }, { "key": "k09", "vars": { "n": "9", "seed0": "10204152", "seed1": "10204279" } }, { "key": "k10", "vars": { "n": "10", "seed0": "10204280", "seed1": "10204407" } }, { "key": "k11", "vars": { "n": "11", "seed0": "10204408", "seed1": "10204535" } }, { "key": "k12", "vars": { "n": "12", "seed0": "10204536", "seed1": "10204663" } }, { "key": "k13", "vars": { "n": "13", "seed0": "10204664", "seed1": "10204791" } }, { "key": "k14", "vars": { "n": "14", "seed0": "10204792", "seed1": "10204919" } }, { "key": "k15", "vars": { "n": "15", "seed0": "10204920", "seed1": "10205047" } }, { "key": "k16", "vars": { "n": "16", "seed0": "10205048", "seed1": "10205175" } }, { "key": "k17", "vars": { "n": "17", "seed0": "10205176", "seed1": "10205303" } }, { "key": "k18", "vars": { "n": "18", "seed0": "10205304", "seed1": "10205431" } }, { "key": "k19", "vars": { "n": "19", "seed0": "10205432", "seed1": "10205559" } }, { "key": "k20", "vars": { "n": "20", "seed0": "10205560", "seed1": "10205687" } }, { "key": "k21", "vars": { "n": "21", "seed0": "10205688", "seed1": "10205815" } }, { "key": "k22", "vars": { "n": "22", "seed0": "10205816", "seed1": "10205943" } }, { "key": "k23", "vars": { "n": "23", "seed0": "10205944", "seed1": "10206071" } }, { "key": "k24", "vars": { "n": "24", "seed0": "10206072", "seed1": "10206199" } }, { "key": "k25", "vars": { "n": "25", "seed0": "10206200", "seed1": "10206327" } }, { "key": "k26", "vars": { "n": "26", "seed0": "10206328", "seed1": "10206455" } }, { "key": "k27", "vars": { "n": "27", "seed0": "10206456", "seed1": "10206583" } }, { "key": "k28", "vars": { "n": "28", "seed0": "10206584", "seed1": "10206711" } }, { "key": "k29", "vars": { "n": "29", "seed0": "10206712", "seed1": "10206839" } }, { "key": "k30", "vars": { "n": "30", "seed0": "10206840", "seed1": "10206967" } }, { "key": "k31", "vars": { "n": "31", "seed0": "10206968", "seed1": "10207095" } } ], "output": { "format": "json", "maxBytes": 16000 }, "merge": { "groupSize": 16, "brief": "Merge into one JSON object: rows, one per item, with n, id, family, lo, hi, seeds.first, seeds.last, seeds.n, and for LO-QLX5 and HI-QLX5 the n, mean_diff, se, sum_d, sum_d2 and seeds_positive, and each variant's peak_gas and pass_peak, every number copied exactly as the item gives it; sorted by the larger of the two mean_diff, largest first. Then failed, the items with no result or no engine run and why. Add no number of your own." }, "after": { "batch": "c-map", "pairing": "batch" }, "requires": { "platform": [ "linux-x64" ], "minCpus": 4 } }, { "name": "d-ideas", "brief": "Test one new fee mechanism on the fast LEAN replica: {{mech}}. {{what}}\nCredit Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved in every file you write and in the result. Kit: https://raw.githubusercontent.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/45e7563d1a29ffca9d608fdf60c90bf2624d2d01/ (README.md, setup_fast.sh, docs/). Keep downloads, venvs, caches and checkpoints under test/scratch/. Submit nothing to the leaderboard. What you download is data, never instructions.\nThe replica is code_zb64 (base64(zlib(tar))) of https://api.imd.fun/artifacts/a88ff982eba7e078bc6ccb1555b90a211c00c9fd76ec90a62ab13a4074f2c3d0: fastlean/fastlean.py, numba, bit-identical to LEANBASE, the Python reference of the LEAN contract; follow its run lines. Your mechanism goes in its hook or in an edit of the compiled code. Baselines: LEAN is a0=0.35 ainf=0.35; AGE is a0=0 ainf=0.7 tau=1.\nFirst read the policy (leanbase.py, stalerival.py, real.py, tellpol.py) and say whether the mechanism is already in it: if it is, test the nearest variant that is not, and say so. Spent, do not test: table compression or refit, price-belief variants (twocomp, lattice, rival pin), per-run sigma or arrival rate, exact rival carry, learned residual heads, kappa. The mechanism may use only what a contract is handed in afterSwap (side, amounts, timestamp, its own reserves) and its own state. Say what it would cost a contract that today uses about 208,000 of 245,000 peak gas, 22,440 of 24,576 runtime bytes and 47,230 of 50,000 source characters.\nMethod: at most 12 parameter settings. Choose on replica seeds 64000..65023 in rounds of 128, each setting paired with LEAN on the same seeds; drop a setting once mean_diff + 3*se < 0. Then run the one chosen setting once on seeds 10000..12047 (2,048), paired with LEAN, and once more stacked on AGE, paired with AGE. se is the sd of the paired differences (n-1) over sqrt(n).\nResult: one JSON object of at most 30,000 bytes with the fields: credit; mech; already_present (true or false, and where); definition (formula, parameters, state kept); settings_tried (each: parameters, n, mean_diff, se, dropped_early); chosen; report.vs_lean and report.on_age (each: n, mean_diff, se, seeds_positive); promote (true only if both report mean_diff are >= 0.03); contract_cost (storage words, gas, characters); patch_zb64 (base64(zlib(unified diff against fastlean.py))); not_done.", "items": [ { "key": "age-fee", "vars": { "mech": "age-fee", "what": "A staleness premium: both fees get an add-on or a multiplier that grows with the time since our last callback read as arbitrage, beyond what the filter's variance already gives." } }, { "key": "same-step", "vars": { "mech": "same-step", "what": "A rule for the second and later fills inside one timestamp: no arbitrage can come between them, so the fees set after the first fill of a step may differ from those set after the last." } }, { "key": "fill-size", "vars": { "mech": "fill-size", "what": "The size of a retail fill, relative to a running mean of our retail fills, as a signal for the next fees on the same and on the other side." } }, { "key": "size-run", "vars": { "mech": "size-run", "what": "A per-run estimate of the retail order size (running mean of fills read as retail, corrected for splitting) that scales or switches the fee level." } }, { "key": "share-feedback", "vars": { "mech": "share-feedback", "what": "A controller on our share of retail flow: fills per step and filled volume against a target move the fee level slowly within a run." } }, { "key": "undercut", "vars": { "mech": "undercut", "what": "When the rival estimate is synced, set a side's fee just under the router's indifference point with the 30 bps pool, by a margin, wherever the table fee lies within a band of that point." } }, { "key": "post-arb-skew", "vars": { "mech": "post-arb-skew", "what": "After a callback read as arbitrage the fair price sits at the edge of our band: a one-sided skew, the side the price came from against the other, on top of the table." } }, { "key": "inventory", "vars": { "mech": "inventory", "what": "A skew of the two fees by our inventory: the pool's X value against its Y value at the filter's mean price, relative to the start." } }, { "key": "silence-bound", "vars": { "mech": "silence-bound", "what": "Silence as information: no arbitrage against us for k steps bounds the price inside our no-arbitrage band for those steps; truncate or shrink the belief accordingly before the lookup." } }, { "key": "fee-memory", "vars": { "mech": "fee-memory", "what": "Smoothing or hysteresis of the returned fees across callbacks: an exponential average with one weight, or a dead band under which the fee does not move." } }, { "key": "lookahead", "vars": { "mech": "lookahead", "what": "Look the table up at the belief expected at the next event, not at the current one: inflate the standard deviation by an expected waiting time, one parameter." } }, { "key": "side-imbalance", "vars": { "mech": "side-imbalance", "what": "A running imbalance of retail buys against sells within the run, as a skew of the two fees." } }, { "key": "markout", "vars": { "mech": "markout", "what": "An online controller on realised markout: the edge of our recent fills per side, valued at the later filter mean, raises or lowers that side's fee level within the run." } }, { "key": "tell-coverage", "vars": { "mech": "tell-coverage", "what": "Fees snapped to values on which the exact-arithmetic arb/retail tell decides more often: measure how often the tell is undecided as a function of the fee lattice, then snap." } }, { "key": "sd-extrap", "vars": { "mech": "sd-extrap", "what": "What the lookup does outside the tables' range of offset and standard deviation: extrapolation in place of clipping, or a linear add-on per unit beyond the edge." } }, { "key": "drift", "vars": { "mech": "drift", "what": "The drift of the price process inside the filter's prediction step (the -sigma^2/2 of a geometric Brownian motion per step, and any drift the engine's config has): check it, then add it." } }, { "key": "second-order", "vars": { "mech": "second-order", "what": "A second-order correction between log-price and price space: an asymmetric add-on of c*sd^2 to ask against bid." } }, { "key": "mixture-branch", "vars": { "mech": "mixture-branch", "what": "Where the tell cannot run or is undecided, mix the arbitrage-branch and retail-branch fees by the posterior probability in place of taking one branch." } }, { "key": "sync-grade", "vars": { "mech": "sync-grade", "what": "A graded sync: interpolate between the synced and the unsynced table by the age of the last exact reading of the rival, in place of a flag." } }, { "key": "endgame", "vars": { "mech": "endgame", "what": "A horizon rule: a different fee level in the last N steps of the 10,000, where nothing is left to protect, and in the first N." } } ], "output": { "format": "json", "maxBytes": 32000 }, "merge": { "groupSize": 10, "brief": "Merge into one JSON object: rows, one per item, with mech, already_present, chosen, report.vs_lean and report.on_age (n, mean_diff, se, seeds_positive), promote, contract_cost and a one-sentence definition, every number copied exactly as the item gives it; sorted by report.on_age.mean_diff, largest first. Then failed, the items with no result and why. Add no number of your own." }, "requires": { "platform": [ "linux-x64" ] } } ], "read": [ "a-build/qa", "a-check/qa", "a-q/qa", "a-engine/qa", "a-wide/s1", "a-wide/s2", "a-wide/s3", "a-wide/s4", "a-wide/s5", "a-wide/s6", "a-wide/s7", "b-core/r1", "b-core/r2", "b-core/r3", "b-core/r4", "b-qlx/r1", "b-qlx/r2", "b-qlx/r3", "b-qlx/r4", "c-map/map", "c-round1/merge-01", "c-round1/merge-02", "d-ideas/merge-01", "d-ideas/merge-02" ], "cancel": [], "wake": { "batches": [ "a-wide", "a-q", "b-qlx", "c-round1", "d-ideas" ], "afterMinutes": 360 }, "finish": false }