# wavg-offsets

## Design

Credit: Taylor (gtmcknight) developed the Gaussian filter and qm tables. This variant starts from [qt1's Python reference](https://api.imd.fun/artifacts/8a6e303b662e1a5ea9bb47f31acedd3988ef65b3ddb66d074517aa59ad41ca40) and uses the [compressed QMS1 blob](https://api.imd.fun/artifacts/17d249ab0c33fc44931d9b105cf3f9e3846a560bd518b67310c2a56defacdecc). On a step's first own trade with `0.005 < pi < 0.995`, it looks up the arb offsets at the arb reading with a phase-0, zero-sd, band-clipped rival; it also looks up the cut-prior retail offsets with phase 1, `sqrt(vt)` and the retail-updated rival. It averages each offset using `pi`, then uses qt1's fee conversion against the carried posterior mean. The filter, carried state updates and all other callback quotes follow qt1. Taylor's [filter description](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/README.md) defines these two components and rival updates.

Each affected callback uses two ask/bid offset-pair lookups (four A/B surface reads). No constants were tuned. The 10,167-byte blob is embedded below so the reference can run offline.

## Screen

Paired `replica2.run` against qt1-ref, one run of each policy per seed. Taylor's [replica](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/replica2.py) uses different RNG streams from the Rust engine, so these edge values are replica measurements, not board scores. `new_path_calls_per_run` is the mean count of ambiguous first-trade callbacks across variant runs. Standard error uses the sample standard deviation of paired differences divided by `sqrt(n)`.

```json
{
  "variant": "wavg-offsets",
  "base": "qt1-ref",
  "seeds": "60000..60511",
  "n": 512,
  "mean_diff": 0.27726260379404943,
  "se": 0.021458729540657563,
  "worst5": [
    [
      60496,
      -1.8158734762361064
    ],
    [
      60210,
      -1.357729737939735
    ],
    [
      60128,
      -1.3036835403333953
    ],
    [
      60144,
      -1.1196546296076804
    ],
    [
      60199,
      -1.085751131007271
    ]
  ],
  "mean_edge_variant": 529.5531686692844,
  "mean_edge_base": 529.2759060654904,
  "new_path_calls_per_run": 5824.65234375,
  "lookups_per_first_trade": 2
}
```

## Code

Complete `scratch/mix.py`:

```python
"""wavg-offsets variant of qt1, based on Taylor (gtmcknight)'s Gaussian filter
and qm tables. The ambiguous first trade quotes both posterior components.
Standard library only. Usage: from mix import QMRef; QMRef('blob.bin').
Init fees = real.py's init: the full plain pol_mid table at (0,0,0) = 0.002823606104386589 each.
"""
import math, struct

SIG2 = .000945 ** 2
LD_M, LD_S = math.log(11.12e-4), 1.176
INIT = 0.002823606104386589
MAXF = 0.1


def phi(x): return math.exp(-.5 * x * x) / 2.5066282746310002
def Phi(x): return .5 * (1 + math.erf(x / 1.4142135623730951))


def trunc(m, v, lo, hi):
    if v <= 0: return float(lo <= m <= hi), m, 0.
    sd = math.sqrt(v); a = (lo - m) / sd; b = (hi - m) / sd; z = Phi(b) - Phi(a)
    if z < 1e-12: return z, lo if m < lo else hi, v * .25
    pa, pb = phi(a), phi(b); r = (pa - pb) / z
    return z, m + sd * r, max(0, v * (1 + (a * pa - b * pb) / z - r * r))


def parse(blob):
    o = [0]
    def rd(fmt):
        v = struct.unpack_from('<' + fmt, blob, o[0]); o[0] += struct.calcsize('<' + fmt); return v
    assert blob[:4] == b'QMS1'; o[0] = 4
    form, ntab, nw, w0, h, ns = rd('BBHHBB'); assert form == 3
    S = list(rd('%dB' % ns)); n2 = rd('B')[0]; W2L = list(rd('%dh' % n2)); fb = rd('B')[0]
    tabs = []
    for _ in range(ntab):
        nr, nc, nk = rd('BBB')
        kr = list(rd('%dH' % (nr - 4))); kc = list(rd('%dH' % (nc - 4))); ks = list(rd('%dH' % (nk - 4)))
        assert nk == 4 and not ks
        tabs.append([nr, nc, nk, kr, kc])
    for t in tabs:
        t.append(list(rd('%dh' % (t[0] * t[1] * t[2]))))
    assert o[0] == len(blob)
    return dict(NW=nw, W0=w0, H=float(h), S=[float(s) for s in S], W2L=[float(v) for v in W2L], FB=fb, tabs=tabs)


def basis(knots, x):
    """all cubic B-spline basis values at x (Cox-de Boor recursion), right end included"""
    t = knots; n = len(t) - 4
    B = [1.0 if t[m] <= x < t[m + 1] else 0.0 for m in range(len(t) - 1)]
    if x >= t[-1]:
        last = max(m for m in range(len(t) - 1) if t[m] < t[m + 1]); B = [0.0] * (len(t) - 1); B[last] = 1.0
    for d in range(1, 4):
        Bn = [0.0] * (len(t) - 1 - d)
        for m in range(len(t) - 1 - d):
            a = t[m + d] - t[m]; b = t[m + d + 1] - t[m + 1]
            if a > 0: Bn[m] += (x - t[m]) / a * B[m]
            if b > 0: Bn[m] += (t[m + d + 1] - x) / b * B[m + 1]
        B = Bn
    return B[:n]


def surfaces(P):
    """F[t][level][row][col] = max(0, spline) at the grid nodes, in bps"""
    out = []
    for ti, (nr, nc, nk, kr, kc, C) in enumerate(P['tabs']):
        ncol = 2 * P['FB'] + 1 if ti == 0 else len(P['W2L'])
        Kr = [0.0] * 4 + [v / 64 for v in kr] + [P['NW'] - 1.0] * 4
        Kc = [0.0] * 4 + [v / 64 for v in kc] + [ncol - 1.0] * 4
        Ks = [0.0] * 4 + [len(P['S']) - 1.0] * 4
        Br = [basis(Kr, i) for i in range(P['NW'])]; Bc = [basis(Kc, j) for j in range(ncol)]
        Bs = [basis(Ks, l) for l in range(len(P['S']))]
        F = []
        for l in range(len(P['S'])):
            D = [[sum(Bs[l][s] * C[(s * nr + r) * nc + c] for s in range(nk)) / 8.0 for c in range(nc)] for r in range(nr)]
            E = [[sum(D[r][c] * Bc[j][c] for c in range(nc)) for j in range(ncol)] for r in range(nr)]
            F.append([[max(0.0, sum(Br[i][r] * E[r][j] for r in range(nr))) for j in range(ncol)] for i in range(P['NW'])])
        out.append(F)
    return out


class Tables:
    """A/B exactly as qms_decode.to_qm writes them (rounded to 6 decimals)"""
    def __init__(self, blob):
        P = parse(blob); self.P = P
        NW = P['NW']; w = [(i - P['W0']) * P['H'] for i in range(NW)]
        self.A = {}; self.B = {}
        for tag, F in zip(['0c', '1s', '1c', '2s', '2c'], surfaces(P)):
            A = [[[round(F[l][i][j] + w[i], 6) for j in range(len(F[l][i]))] for i in range(NW)] for l in range(len(F))]
            self.A[tag] = A
            self.B[tag] = [[row[::-1] for row in A[l][::-1]] for l in range(len(A))]


class QMRef:
    wants_j = True
    _cache = {}
    def __init__(self, blob_path):
        if blob_path not in QMRef._cache: QMRef._cache[blob_path] = Tables(open(blob_path, 'rb').read())
        self.T = QMRef._cache[blob_path]; P = self.T.P
        self.S = P['S']; self.W0 = P['W0']; self.NW = P['NW']; self.h = P['H']; self.FB = P['FB']; self.W2L = P['W2L']
        self.m = math.log(100); self.v = 0.; self.tlast = 0; self.cnt = 0; self.s2h = 100.; self.fb = self.fa = .003
        self.sp = 100.; self.synced = False
        self.new_path_calls = 0
    def _pos2(self, v):
        W = self.W2L; n = len(W)
        if v <= W[0]: return 0.0
        if v >= W[n - 1]: return float(n - 1)
        lo, hi = 0, n - 1
        while hi - lo > 1:
            mid = (lo + hi) // 2
            if W[mid] <= v: lo = mid
            else: hi = mid
        return lo + (v - W[lo]) / (W[hi] - W[lo])
    def lookup_offsets(self, w, w2, phs, sd, synced=None):
        S = self.S; k = 0
        while k < len(S) - 2 and sd >= S[k + 1]: k += 1
        tt = min(1.0, max(0.0, (sd - S[k]) / (S[k + 1] - S[k])))
        tag = '0c' if phs == 0 else (str(phs) + ('s' if (self.synced if synced is None else synced) else 'c'))
        A, B = self.T.A[tag], self.T.B[tag]
        pw = min(self.NW - 1.0, max(0.0, w / self.h + self.W0))
        l2 = w2 / self.h
        if phs == 0:
            l2 = min(self.FB, max(-self.FB, l2)); p2 = l2 + self.FB; n2 = 2 * self.FB + 1
        else:
            p2 = self._pos2(l2); n2 = len(self.W2L)
        i = min(int(pw), self.NW - 2); j = min(int(p2), n2 - 2); f = pw - i; g = p2 - j
        def bl(Tb):
            return (Tb[i][j] * (1 - f) + Tb[i + 1][j] * f) * (1 - g) + (Tb[i][j + 1] * (1 - f) + Tb[i + 1][j + 1] * f) * g
        a = bl(A[k]) * (1 - tt) + bl(A[k + 1]) * tt
        b = bl(B[k]) * (1 - tt) + bl(B[k + 1]) * tt
        return a, b
    def fees_from_offsets(self, a, b, w):
        fa = 1.0 - math.exp(-(a - w) * 1e-4) if a > w else 0.0
        fb = 1.0 - math.exp(-(b + w) * 1e-4) if b > -w else 0.0
        return fb, fa
    def lookup(self, w, w2, phs, sd):
        a, b = self.lookup_offsets(w, w2, phs, sd)
        return self.fees_from_offsets(a, b, w)
    def init(self, *args):
        self.fb = self.fa = INIT; return INIT, INIT
    def on_trade(self, is_buy, ax, ay, t, x, y, arb=False, p=100., s2=100., j=0):
        s = y / x; dt = t - self.tlast; is_arb = False; mix_parts = None
        if dt >= 1:
            self.cnt = 0; lo = math.log(self.sp * (1 - self.fb)); hi = math.log(self.sp / (1 - self.fa)); m, v = self.m, self.v
            for _ in range(min(dt - 1, 12)):
                v += SIG2; _, m, v = trunc(m, v, lo, hi)
            v += SIG2
            lp = math.log(s * (1 - self.fb)) if is_buy else math.log(s / (1 - self.fa)); sd = math.sqrt(v)
            la = phi((lp - m) / sd) / sd; Z, mt, vt = trunc(m, v, lo, hi); d = max(abs(math.log(s / self.sp)), 1e-9)
            lr = Z * .26 * phi((math.log(d) - LD_M) / LD_S) / (d * LD_S)
            pi = la / (la + lr) if la + lr > 0 else 0.; is_arb = pi > .5
            if .005 < pi < .995:
                m2 = pi * lp + (1 - pi) * mt; self.m, self.v = m2, pi * (lp - m2) ** 2 + (1 - pi) * (vt + (mt - m2) ** 2)
                # Each hypothesis starts from the same pre-step rival estimate.
                pa = math.exp(lp); pr = math.exp(mt); old_s2 = self.s2h
                s2_arb = max(pa * .997, min(pa / .997, old_s2))
                s2_ret = max(pr * .997, min(pr / .997, old_s2))
                cand_ret = s * (1 - self.fb) / .997 if is_buy else s * .997 / (1 - self.fa)
                synced_ret = (cand_ret < s2_ret) if is_buy else (cand_ret > s2_ret)
                if synced_ret: s2_ret = cand_ret
                mix_parts = (pi, lp, mt, vt, s2_arb, s2_ret, synced_ret)
            elif is_arb: self.m, self.v = lp, 0.
            else: self.m, self.v = mt, vt
            pe = math.exp(self.m); self.s2h = max(pe * .997, min(pe / .997, self.s2h)); self.synced = False
        if not is_arb:
            cand = s * (1 - self.fb) / .997 if is_buy else s * .997 / (1 - self.fa)
            if (cand < self.s2h) if is_buy else (cand > self.s2h): self.s2h = cand; self.synced = True
            self.cnt += 1; ph = 1 if self.cnt == 1 else 2
        else: ph = 0
        self.tlast = t; self.sp = s
        if mix_parts is None:
            fb, fa = self.lookup((math.log(s) - self.m) * 1e4, (math.log(self.s2h) - self.m) * 1e4, ph, math.sqrt(self.v) * 1e4)
        else:
            pi, lp, mt, vt, s2_arb, s2_ret, synced_ret = mix_parts
            log_s = math.log(s)
            aa, ba = self.lookup_offsets((log_s - lp) * 1e4, (math.log(s2_arb) - lp) * 1e4, 0, 0.)
            ar, br = self.lookup_offsets((log_s - mt) * 1e4, (math.log(s2_ret) - mt) * 1e4, 1, math.sqrt(vt) * 1e4, synced_ret)
            a = pi * aa + (1 - pi) * ar; b = pi * ba + (1 - pi) * br
            fb, fa = self.fees_from_offsets(a, b, (log_s - self.m) * 1e4)
            self.new_path_calls += 1
        self.fb, self.fa = min(MAXF, max(0.0, fb)), min(MAXF, max(0.0, fa))
        return fb, fa
```

`blob.bin` as base64, from the [qm-spline data](https://api.imd.fun/artifacts/17d249ab0c33fc44931d9b105cf3f9e3846a560bd518b67310c2a56defacdecc); decode before running the code above:

```text
UU1TMQMFQQGgAAUIAAQIDBAUGiIxYP9+/5z/sP/E/87/2P/i/+f/7P/v//L/9P/1//b/9//4//n/+v/7//z//f/+////AAABAAIA
AwAEAAUABgAHAAgACQAKAAsADAAOABEAFAAZAB4AKAAyADwAUABkAIIAoAAGGAoE0REHHiEitCOKJAclUSWZJRAm/iYCKfApZyqv
KvkqditMLN8t+TEvPgsAGwC4AEgC4ALwAhgOBMUS2CD0I98kdyX5JXcm7yZgJ8wnNCigKBEpiSkHKokqISsMLCgvOz3wAlcECgVz
BdAFMAaNBvYGqQcQCRIMBCMYZSIMJdMlciYJJ6snVSj3KI4pLSr0Kpst3Td/BMAERAW7BUUGvAZAB4EHGA4EtxJMIJUjtCRnJfcl
dybtJl4nyic2KKIoEymJKQkqmSpMK2sstC9JPbsCHQTgBGMFzQUzBp0GIAfjB0UJDAgEsh44JP4lPCfEKAIqyCtOMY8EewWFBnEH
PhgAADkYRxhGGGMYgBhSGAAAYhiJFAAAqhR4FMsUZRQcFPMUAACkFFAOAAAfDngOFQ7JDlcPDg4AAJcORgcAAGoHMgePBy8Hmwax
BwAAPQe6AwAAoAPXA70DDQQGBkYFAADNBYECAABvAqUCbwItBesC7gMAADkDAQIAAFQC1QEmA1gCWAPHBgAAmwXMAQAAtQHzARQC
pQNVA6wAAADZAbIBAADqAZUBlALMAfgCqgMAAF0DlwEAAHgBxAG1AQgDbwIxAwAAEwNiAQAAdgEzAQACwgGiAnMBAAC8AfoAAAAF
AiUBlADtAYIBlwIAAO0BawEAABf+fgGr/+IA5wDEAAAA+ABB/QAAJQEtAB4Az/9zAIoAAACEAOoBAAAD/9b/r//f//n/IAAAAB8A
sv0AAA4ACgD0/xQA7v8MAAAAAABNAAAAw/8IAPv//f8DAP7/AAD9/8L/AAD7/wEA/v8CAP7/AgAAAAEAAQAAAAAAAAAAAP//AAAA
AAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAAAAAAAAANhgAAMYXchiqF0QZrBjbFwAAWhiBFAAAiRWwE0sWWBFuEyYVAABKFEUOAADf
DC0PMwwLEiEQCQ4AAAQPRAcAAOMH1AZcCJoFTgYKBwAAtAa6AwAAeQPsA2kDygQtBjoFAAC6BYcCAACmAngCDAMlBCADEQQAAK4D
DwIAANsBOAJQAnwDkAOOBAAAPwPaAQAA/wHIAWwC9AKzAiMDAAA6A8MBAABwAegBxgE9A6sCnwMAAEADtgEAABsCcQEMAmkCHwNV
AgAAAwJmAQAAZgDeASsBpAJrAaUDAABzA/YAAABpA63/JQJpAKoCjQAAAKgBIgAAANf6HAKW/iQCOQA3AgAAFAHf/wAA9w0O/MgC
pv4aAVb/AAB0ADgCAADL7OgEEv7DAGb/JQEAAAoAyv4AAHIGa/0MAWr/cQAN/wAA0P9aAAAAxf18AKb/RwDO/1wAAAAUAOv/AABf
ANr/HwDo/xIAz/8AAPT/AgAAAOn/CQD2/woA+f8PAAAABAD//wAACwD6/wcA+f8FAPL/AAD+/wEAAADy/wgA9f8MAPf/KQAAAAcA
//8AABYA8/8SAOr/FgBP/wAA5v8BAAAA8f8JAPP/EQDs/24AAAATAAAAAAAFAP3/BAD6/wUAxP8AAPr/UhgAAM8YGxgdGckXRRj5
GAAAfRitFAAAiROBFf8SgRciFrYUAACVFWAOAADwD4gNwhDmC/gM1g4AALwNXgcAAIkG/gcwBigJLwmCCAAA7gj6AwAATQToA9kE
2QTLA8wEAABxBO0CAACnAjEDCQPDAogEjgMAAO4DSwIAAJwCXQJvAh4D6QItAgAAHwMSAgAAogFIAugBoAL3ApIDAAABA8sBAAC3
AogBWQIlAsYCMgIAAIYCyAEAAKAALgJKAYcCdgJmAgAA7QJoAQAATwOYAHACaQFeAmcCAADsAQIBAADK/TYC9v7eAvoAVQIAANYB
yP8AAOUEdv7mATT/nAFEAAAA/wC4AAAAc/aoAn78hwGv/yEBAABcANn7AAC0FMf22QWb/EABpf4AAEoAfgEAAC35VANc/YMBKf/L
AAAAyv9k/wAAUQN7/jABI/9iAMb/AAAeABYAAABe/08AsP84AOX/yv8AAMX//v8AADcA4f8eAOb/BgAoAAAAFgABAAAA6f8OAPD/
DgD9/6r/AADS////AAAkAOr/GwDl//7/PQAAACwAAQAAANX/GgDa/yUA8/8JAAAAlv///wAAHQDu/xkA5f8MAOf/AAA8AAAAAAD4
/wUA+P8IAPv/FAAAANP/ABgAAO8XExgMGFQYUBgyGAAASRhMFAAAgBQ6FMUUPhRZFKIUAAByFB4OAADWDVAO3g2yDr0OVg4AAJ0O
TwcAAIMHOwfSB30HZwekBwAAfAcSBAAA/gMqBCgETQTbBHYEAACSBMgCAADyAsACIAOvAy0DpQMAAIgDagIAADICZgKyAsUCEgM9
AwAABQMuAgAAcgL+AYQCjgLiAoACAADSAi0CAACKATgC6AG2AlcCBwMAAKsC7AEAAKwCngFKAgMCrAJtAgAAeQLVAQAA/wAzAhQB
oALZAW0CAABGAkIBAAAzAvUArgHjAPEBWgEAAKEBuQAAAJT/IQHw/zQBjwBAAQAA9QAMAAAA6gDR/7IAlv+OABIAAABjABAAAABV
/l0AM/9VALT/iQAAAA0Asv8AAKIAm/9DAOL/CwDp/wAA4P8IAAAAiv8uANf/EAD+/93/AAABAPr/AAAQAPT/BgAAAPv/HQAAAAUA
//8AAP3/AgD///7/BADh/wAA+/8AAAAA/P8CAPz/BAD6/xgAAAAFAAAAAAADAP//AQD+/wQA2v8AAPj/AAAAAAEA//8BAAAA/f8X
AAAACAAAAAAA//8BAP//AQABAPT/AAD3/wAAAAABAP//AQAAAP//AQAAAAEABhgGGAoYIhgsGCwYDxhiGE4YdRiTGN4XCRgrGBsU
NRQbFGEULBRyFMkUtBNFE0MSlhNlFb8VsBRbDTINbQ08DZENRA3dDDAOFA/nDxUPAgy7CgIN8AX/Bd8FJAb/BTYGgwa3BQ8FngS+
BLQGigmYB2ICRQKBAmACnwKHAkkC2gKYAzwEygSuBCoEdwQ1AYMBkwG7AcUB5gEZAyoDMQMUAwwDPQPsA5ID8QBDAR0BpQGYATgC
DgIrAnkCxwIrAy0DPQNCA5QB4P+GAQMBhAGqARICQgJWAnYClQKyAj8DFAMSASAA2AD5AD0BrgGWAdIB9AEyAm4CkwK2ArQCRAD2
/4cA4QD2AC8BkAGRAccB4QEwAgICGQOUAtIAsv7TAEgADgEKAScBWAFkAbgBvQFHAkcCsQE5/tj/yv+hADoBgwAGAfwAQQFhAaMB
HgI1AjkKS/sqA7v9JAG0AIUA4gDGACAB5AC9AcoAhgY6B2UCFP2sANgAtADAABUAgQDmAJIAqQGAAI0GRgT9/pX/fQBjAE8AMQBY
AH0AbwBwAI4B5f/pBh0F1/4LAEIAPQA+AEsAx//w/1IAaADjAEsA8wUHAyoA3//Y/ywA5v/q/x8A7v/G/xAA9wBC/w4HvgPy//3/
GADX/wwA/P/z//f/FQDK/zMA8P//BNEAAwD3////BQD///n/BwD2/wIA9v8QAFf/jAX0AgIA+f8IAPf/BgD2/woA5f8ZAMj/XgDN
/twCEgH8/wgA9v8JAPj/DADw/yEA1/8+AJr/d/1GACb8AwD3/wwA8v8JAO7/EwDM/zIAof9wALsD4QEOAf7/BQD5/wgA+/8JAPb/
GQDn/ykA5/9b+9j8CAAAAP7/AwD8/wIA/f8DAPb/BwDt/xEAZgCaAOf/+xfZF9YXvBdWGGUX5he+GTEaPxm2F6UXLRjBFy4UoROd
FOcUyBMSFocUDA8TELIS7RRbFbsTrRUDDc0NWgxADN0NPAtgDGcVIhMvEUMM6AvzDZAKxgXoBekF9QapBSQH7waZAeYCPgMDBk4H
0gb0CJMCGAKEAisCqAIsAvgBoARLBNQEYgR+BJsEmQS8/1QB0wG3AdUBXQL0Am4CygLkAngDKwO9A3kD5wLe/+IBiwG/AbEBSwKY
As4C6wL4AgYDkAOHA///UgAoAUcBewHNAeUBFgJLAnMCvwK2AhEDdgKF/w0A/wAvAS0BPQHLAegBBgI3AmcCfgLiAuUDvgM9//0A
rwAtAUQBMgGzAbkB+QH9AWsCqQLfAHjuMwJL/y0BbgDjADgBRQGuAXUBRwKsAeICwgWpC0z7+gGy/3kA3gDSACABTgGpAXQBjQKt
AagFwfdeAlj/KQAkAFQAugDUAPsARgG5AYMBRgSgA0X/eARz/sn/UwD1/7sAbQAGASoBNgEoAW8FjgoaAev6DQLj//4A5/8tAI8A
QQDIAPkAwAFjAV4ICv8SBIX9WAGQ/woB4//4/7QAdADHACUB/wIxCIAAy/1+AUn/dgCF/3j/KQCn/xIA5gDO/1cENwmw/zYBKv9l
AMD/EgBsAIn/egC6/yAAKAG4AQENEgCd/zwA5/8SAPr/1/87AKn/ZQC2/7P/eQIOFPz/6P8NAOz/CgC4/2IAyf7OAM7+RgF3/hYD
3wQEAPv/CQAFAAoAGgDE/3gAb/8HAZT/ugCj+pwB8v8kAL//JQCF/20AX/46AoX7RQTd7eUXcv6lAAkA4/8wANz/VgBu/3IBpfyp
BMP3eBFl3cgBzv/8/wwA6v8PANP/KABg/8QALf5pAUr5Xgbh/wYAGRhrGAEYlhg3GPkYwhhgFxcXmhfFGLkYdRi8GA4UDxU5FJMT
dRS+EpwTzhc6F/0V/BMPFIcVVxTPDZEM/Q1hDs8Niw+BD2UIQwrWCuQOfw66DNIO4QVhBpgFlwX/BTgF0wROCWQIXAgzBgEGHAib
Bg8CUgLeAmkCQAPEA6YEigJeA1IDUwRQBOUEmwSOAaUAIALYAS0COgLEAbYCuwIXAxQDpAPBA7UDz//rAawBmwHBAfsB3QEiAkMC
iwL9AkkDWwN7AyEAqQBlAYEBegGTAbwB4QEDAlgCkQLuAkYDTgM4/xoBJQEOAS4BhAFhAcUB9QEfAnkCuQIOA9ECNP7KAIYAIgHH
AAQBaQFQAb0B3QF+AkwCOwNcA3kE3/8UAYQA0QDvAOsAQwFbAeMB8wHvAloCTQOq98gCRf/lAHoAXgDmANoAMQFCARUCmgH3BBEG
egWv/MMAXgBSAIsAawDFAO4ATwFfATMCnQEiB+4A2fqYAVf/GQAPACwAkwCDAOwARwHuAX0AMwPy/LsI8fvZ//L+QAD9/yEAjQC7
ADIB2AAqBXUHXQIi+CYEzv2cAJn92P8CAPr/cgDGAE0BZwEeBm3+cQRX/RQBSv9xAQIA9v/M/2sAOgCaARkBnwiRAKX9ZwFq/1oA
Pf+5/6kAgv+h/50A//9FAckC2P+JAK7/GwDw/yIATwAh/7EA2/+w/5gA8gJ1AwwAy/8nAPL/DQDc/+P/aADb/3r+CgL0+s0FA/35
/xQA+v/t/xoArv8hATv9vQJy+2wIgv3//d8BCgDi/xUACgD+/0wA9P7bAtD9MAbh87MB6AQu/Pv/EAD1//n/AwDM/6oAOv45Aab8
ZAWfAgr7mQECAPn/BgAAAAEADgC2/4QAnf9UASf9nwCeAKL/OxftFjkX2BfNF9AXwxdBGC8YLBgUGBsYXRhSGEkTGhNXEwUUBBSN
FKkUZRPfE/UTTxRdFFoUgRSBDHEMYgw+DQANrgxJDK4OwA3sDWYNbg39DbANjwX0BVgFEAZEBuMGRgeiBUYGRgamBtAGrQboBpAC
YQJGA48CEAOmAoACpQNjA5QDdQOOAy0EFwRpAUsBVgIRAvwBVwLJAngCsQLEAhADHgPHA7wDZQF9AbEB7gHSAfgBKwJAAlwCfgKv
AscCrgOKA8UA+gDXAbEBswHYAekB+wEqAkICkQK9AqMDhQOzABMBFgGfAXYBfgHFAcUB2wENAkwCnAKMA5MDZgBqAFABPQFXAVwB
VAGjAaEB1QERAoICrwOiAwgALgC6AB4BGAH8AEMBPwF1AXoB2QEVAv4D1AMgAAcAzQDiAOcA/ADiABgBPAFVAbwBowElBOUDWP9A
/w8BUQDeAIMAzwDOAPYAGwFkAbgBGARoBGT/mQDc/9UAigCLAH8AkADOAOQAMQGvAfIDfgR8AOL92AAkAIgATQBGAGsAZgCuAO0A
QwERAw4EYP9bAVH/QwDR/5EA9f8fAFoAYgCqAFIB+wLlA0MAzf60AMX/LgBY/xEAiv++/yAAmwAyAEQEDgPQ/2sAmf8TAPL/LQAd
ANn/VQC8/y0AwgB+AgEDBwDe/xYA+v8GAOb/4P8uAKb/0/8AAHn/wAOeAvr/DQDu/wYA9/8QAPv/DAAGAOv/qADT/ocB1QECAPz/
AgADAPX/DQB7/7cAlP4/Aaf7KwIs/jb+/v8EAP3//P8IAPH/eAAy/zABVf7/A+v8EAL9AAEA/v8BAAMA+v8MAKT/igAi/yIBL/1c
AmP+hv///wEA/////wEA/P8PANn/IQCr/3QAff8tAA8AJhg2GB4YKBgsGCkYQxhdGE4YqhjhF1wYKBMoExoTJxM5E0QT4BKWEssS
nBKlE/IS9AsbDO4L/AvyC+ILeAzcDJwMMw16C5MMcwSBBFsEegSHBKIEOwTxAxgEkAPyBBQEqAFkAqkB4gHuAcIBggKZAwYE/gUz
AnwESAEEAtUAmQFsATgE+gQrAfcBxwDoA+0BbAFRAOYB8ADVAYr/JwGfAnoCewOmAbwC+/+IA+H9aAExAFADkAEEAcYB6AHGAdkB
WwHb/0YCnAA1Acb/pwGWATkBcwEJAocB5QANAG4BrwAtANcACQFmAG8BCwE6ATQBPQAtAVb/JQEeAZP/VgAGAZMA+gECACwBQABz
AKD/bgG3ALz/LwDE/7oAygCZAKoAr//OAAT/kP/I/yoA7v8ZAOP/3gAJ/3kAAADx/wYA//8GAPP/CADx/woArf9MAMf/AAAEAP//
AAD9/wYA+v8JAPn/NQDK/xgA///7/wEA//8FAPX/CgDv/w0Al/9cANz/AAACAAAAAQD8/wcA+P8MAPb/SAC8/xYAAAAAAP//AAAB
AP3/AgD8/wIA7f8PAPj/DhjPFz8YExgHGCcZFhhbG9MYNhayGckX9BI1E9USHRMQFMEOWg9tDpERaBccD70TAQwZC5sM4guYCyIP
RxCtDxcO8wWmERwLUQTABPcDhASMBHQDaQL5AlsD9wZSAYoEBwJFARsCzwHoAaUCPwQbBFoEHgLFBusDiwALBFwBoAH0AbgAXwDy
ApECOwRZAL8C4AACAuYASQEcAe8ChQL4AVsCgAGkA2ECBwEUAfYAzwBQAXMAVQFlAsYBHAPXAAcC7gA4/eYBYADiAEgBOgEaAesB
BgKqAAcCdv+PAy//KQBOALEAhQCyAfcAOwJgATsB5P8vAdL93v++/4MA0AAiAAkBHwBIAesAFgGF/acE7v4QAE4AxP8cAWMArgGL
/+cAmP8hASL+agDt/7D/EAA8/x0Abv/AAkD/FQCt/2IABQDs/zUAvf80ADkAn/8r/msA5f9WAJL/9v8IAMH/UADh/6H/NgHF//X/
FwCs/1cAIgDt/5EA+f7JAIoAef5oAP7/9P8jAO7/uv87AAn/jAEV/hMAsgC///7/AgD6//3/FwAAAB4Am/9ZAEz/6v8yAPX/Uhi4
GAgYDBheGHMXJxiXFDoWghuDFukYeBMbE1kT8BOKEmQXwRatGYcYVgxsGH4S7At7DfMKkAtfDGkJxAckBwAIwRPuBnwNvgScA50F
kQSBBMAFFgf6BkEG5QIcB9gExwFKA5UAmALxAtEC6AF6ArECzQQYAUwD+AGYABYCdwF6AVoCyAIVAmAC9gFTA20CwAG8/0ABKgF3
AcwAggECAhMCcAMpAXUCvgG//soB6gDhAGIBkAFuAQECQwEqA/MBdv8uBJH/xAAtANsA2wCgATwBfAInAeMBmgDl/n//ewAwADoA
0QCgAGABrQAKAkQB0P9e/0IBCADv//j/FgDiALEACgLAAP4AQf8b/+v9zf9h/y7/QgDS/3wAfAAVAkgAQgBf/1QB3P87ADcAxP/M
/3QAZgDOADgA7f9FAKb/+P/U/wYA9f/fAK/9MQMs/WcAGgC2/2cACQBKAOn/LQCP/cIDt/f9BY3+7/8xAMv/2f8X/zMAHABEBMb1
AQ5P9qABBQD//+3/TACQAFkAzf73/D0HiPZQBt7+AADz/xwA1P+F/zYAvP93ATT8EQQ+/UoAYxcgF5wX2hewFwcYVRimGKcYShdb
GOYXdRJFEowS+RKlE3oSrBGdET4RzhQCEjYTPAvkCpULlguvCkIMrQ2EDdEN/AkFDbYLZQSLBPEDEAW0BbQEGwRiBLIEVgXZBA0F
XQL6AhcCEALGAVYCDQPqAukCQwJbA7oC2gHRAfMB3wELAsQB5gE9AkgCyAIdAn8CrQGdAacBqQFvAQcC3AHmAQ0C1wGBAhYCLgG8
AVEBVAE6AVYBZwG4AZEB8gLTABUCKQH3ANgAEQFBAeIAUAEbAXcBHwEVAmsB7QAGALMBogDIAL0AvgAQAeUAUwJHAIABUQBdAZH/
jQCHAGUAlQB7AMEAkwBlAdYATgCS/+cAAwBaADkA8f9/AGIAMAEsANcA0v9pAFb/EwDN/wIA9v/0/8//9gDl/40ADgC6/0cA9/8q
ANH/RwBQ/4YA0P6mAKf/6f9IAKH/DgC3/1QAZv8MARD/ggHc/jgAEwCs/2kA3f+LAEX/+gCy/ZsBg/2hAZz/8/8xAMH/EACL/3EA
U/99AXb+2QHV/jkAAQD0/w0A+v8XANj/LwBb/04AcP9WAOT/BxgDGA8YDRghGB8YKxj3FygYPhg+GGcZlRdwGCYUNhQaFFcUMBQ3
FCkUFRUjFKUTxxPeERoV7hNuDWYNeQ1fDYsNnQ2TDYwMog1BDtIOABDUDREOKgYsBhcGRAY2Bi8GQAbnBlgGywVjBUMECAa1BYsC
igKmApcCtQLMAsICLwKPAiEDkAMVBR8FQwV2AYIBuAG8AdIBtgGxAQoDswPZA84DXwNCAwIDfgHcAG8BhQGfAZ4B4AJ2AlMCigLR
AhMDgQOCAyYBSwBCAQ0BRgHpAasBIwJ6ArUCzQKtAtQCnAKzAAcA8wDlAP8AbQHTAd8B9QEjAlYCZQL/ApMCwABX/+cAmwD4AEIB
WQGRAc8BBwIqAjoCEQJdAmb/8/8pAJoAjAD5AD0BVwF+AaYB2QHJAQ8DDgLcAIH9JQHU/yABqQDnABIBPAGGAZMBfALnAL4BDP5D
Aob+hwDQAHQAzwDHABEBGAHGARcBswQiCTMBsf2bAN8ArAC4ACkApQDUAPgAbgG9AG8GGQKj/pcAcwA8AFQANABDAHIATgCiAHwB
BQD1BnYDpADu/+r/fgAeAGYA1f/6/3EAdQAIAUYABAbKBc//9/6NALb/GADQ/xsA6/+//zAAIAFi//UGLwLx/0cA0v8QAPn/CwD3
/wMAEADI/zEA9f94BTcBAwDg/xMA9f8GAPL/CgDq/wwA6v8cABX/Mgb+Af//BgD8/wAAAQD8/wUA6v8YAMn/XADd/nkCUQABAPn/
BQD//wAAAQD+/woA7/8cAOr/2v4//9f+/f8KAPf/BAD8/wUA7v8MAN//IADk/tUDKAEDAAIA+P8IAPz/BQD2/xQA3v8rALn/LAHc
+nr+JQD//wIA/f8BAP7/AQD6/wYA8f8OAKf/rQBOAPP/9RfJFwYYtBcoGBsYbxcKF9sY9Bg/GYYWMBnsFyAU4BP5EwEVtBP3E8wV
TxYjEh8SIhEjFywSRBQjDZ8NMw1LDAIOvw0GC/gJdhADESYSmgqAD9wNKwbqBTYGngYBBg4GnQeCCIMEWgTkATgIzAO2BaECdQKc
AngCugLFAr4BNgFhA6cDmgWlA3MGSgX9ACsB2QG3AdQBpAGZAk8E9QKfAyoDsgPfAlMDkgGRAMABoQGpAQYCXgLUAf0C2wItA8EC
NQRFA6QBU/9FATkBeQFwARMCawJbAnYCqwK7Ap8CtwI4/74A6wArATcBVwGfAdYBBQJsAkoCoQJvAvQC4gFS/8wAwgDlACQBTAHJ
AckB0wEmAgcCtwIWAjT7/gBZAJ8A4AC+ACwBVAGPAdYB6gErAlMCkgLgAEUAef/OAK7/+QDHAB4BhwFSATICwQGJAc0BlwLT+sAC
7P5/ABcAyADeAPsAgAF1AToBNwUZCKH5qgr/+jQADAAJAKMAegASAQMBVwE7AWIFlwcSBNH37AICAP8A7P81AIAAXwAKAbkAdgKy
/cMGmv0uBGn+BAGd/9EA0f8mAIgAgwDTAMIAQAR6BCkBSv5hAMT/KADN/2n/8f+h/2kAqAA3ACAEUgit/94Ak/8/AM3/MgAfADQA
IACe/0wApwALAs4EGABh/1IAyv8mALv/FgCE/wcALwD5/xn/KgXlDvb/GQDv/woA9//0/ywAjv+EAOL+uAAP/+sB3wIHAO//DwD3
/wwAAgC5/1oAP//IAV3+JACz/bz/9/8ZAN//GADD/z8Af//bAM/9Lv/6+hIMyf4tAQUA8P8XAOr/LACu/5YAZf5lAu39tgaF7HUB
xf/+/wUA+f8GAO//EQDS/0cAPP8cALT9FwPj/wEAKBh4GAUYfRhGGEQYvhhqGRgYPhjxF28Z6hehGBQUyBReFJMTbBSJFE4T+BES
FZYUnBVFEpEVTBQaDsgMXQ4rDvoNVA2hD40RLQ2wDTkM0hD5DEAOxQXaBn0FKQbyBZQGaQXAA5YG9QUnCPcDEQiBBj0CmAL4ArQC
WwMqA1UEaAXJAwsFwAHTBhQC2ARnADQBDQLkARcC7gLRAkABQQOjAlcEngLcBHwDWQHiAaEBnwHBAcEBTgHQAvwB0gKJAr4DYgJv
AwP/fgFMAXUBZwG/AZ4BnwEfAmsC2AKwAmQD+AJ0ANgBwAAjAfsAWgFgAdoB5gETAnkClQIHA5gC2v4tAa8A9wDnAPkAUwEyAeIB
FAJ3AmEC1gK3AlYAWQEDAN0AewDdAPAAOQGDAcQBcgIlAh4DSgLx/kL/LwHv/xMBKADgANwAHwHIAVwB1wIxA9sCsP2rA579fQHa
/5IAUgDEAP8ANAHbAbEB1wGNBNAEcvaDAyX/3//9/yEAgQCTACgBMgG4Anb8HQWl/JsG4/3T/t3+0f/x/ykAkwCsAIoBEABZB9kF
ewJE+UYCTf7QAA7+7v/Y/zEAiQDKAPIBsP0sAwD+1AOz/sAAPf8mAeH/GQDW/1oAfgBBAekAHwlvAHf+nwCf/1MAV//d/1IAYv/w
/04AzQCM/yv/3f9/AMj/KQDf/0YAJQBU/6AAzP/V/3IAHwH9CA0AyP8rANn/IgC2//3/MQD1/3P+FQE5/fgCCv/3/xkA7/8NAPn/
//+nAIH+qAEb/5v/+QM3+2AEBwDt/wQA/v/y/zkAkf7OAij8fwTr/U39bwXw+v3/BAAFAPn/EwC2/xMBo/0MA3j7pQLz/279mgEB
AP///P8EAPP/GwBx/8oAcf6HAe7+rAB/AML/LxcEFygXuxelF9wXuRekF9cX4Bf3F80XIhgGGFgTMhMPE/IT8RPxEzsUmhQcFCEU
8BN2FAoUQhSgDL0MegxRDeEMfA3dDGkMMw1CDa4N8AzYDYgNrwXpBZwFBAaNBksG0AZiB8cG4QZlBj4HiAbhBsIC1wInA8sCGANL
AwYD7gJvAwwDBgSiAmUEoAODAZgBYQIoAg8CHQIOAisDYQL7AnwCUwMeA10DrAFCAbAB9AHSAQUCjgL2AYcCZwKxAmACZQP6AvUA
cQG9AbcBswG8AeoBDgIZAj8CXgKXAgADAwMcAY0AVQF9AZQBewHIAbMB5gEKAlECZgIOA/cChgAQARwBSAFFAVMBXAGqAZwB3gEA
An8C+gLqAvAAjf9YAdwAPwECATcBRgFuAXYBxAE0AgMDNAPw/0gBMQApAbAADgHjABwBRAE7AQMCHwEmBIkCEgEd/vcBzf8EAYEA
0ADQAPsANAEwATUCwQE6A3L+oQFf/8sAzwCQAIcAmADVAM4AXwEbAVYFDQKIACX/LgCcAFkAfgBEAGwAcwDLAMcAuAGiADMDfP+z
AMT/UwDQ/3QA+f8lAEsAZwDAACIB3gOTAicAlP/N//j/EACz/8v/wv/2/zIAkQBmAJICOQLu////GgD8//v/IQACADcAuf/V/zIA
vAD7Ao8CAwDz//3/9/8KANH/GACa/10A1//d/47/SAPdAf3/BgD5/wcA8v8kANn/UwCB/6r/ywAZ/1cAoQEBAPz/BAD6/wcA4/8D
ALT/cwBD//D+/wC8/xX+//8CAP//AgD+/wgAGQDs/+j/0P99AX39VgHWAAAAAAAAAAAA//8BAOP/JQDb/18Azf7qAaP+uf8AAAAA
AQD//wEA/f8KAOb/GwC//1YALf9qAPX/KBgIGCAYGxhCGAoYOhgLGMkRshGeEc8RYREfEo8ROBIdCmAKOwohCqsK+AlECr8JkgKV
AmcCsgJdAr0CHwPWAlcDd/z3AfUAiQIqCYL8iQWg/qYGo/siBBEBRP96BCUAtwEH/rgCf/54ABkDz//yAYn/OwAoABMA/v+z/+4A
lf/6/w8A6v/6//z/GgBv/xsA///2/xkACAAGAMf/BAGq/wIACQDr//b/+/8vABb/OwD///b/AAACAP//9v8gAOz/CxhUGJsVoh28
FioO4x/rFdkQtxL4EwEMCw/NIiIHaRQ+C5kHPAnKDAUNEvy3D7MIpAFuBKgC9QE4AeUITgHRAkgCk/9NAeoBYwTn/UwGmwNL/bgH
mgFp/88A7gQD+zwD6gBn/r3+IAGlAXMAjgI+Adz+QAOa/xEAy/7uAfr7fwFoAIf9mwC+/3wAPwBlAT//0P43BMv9LAHx/Z8AVf6+
APkAX/ubAxv9ggNL+28EJP9r/4ABI/4JAlb8YwRs/HQAuBeIGmkWVxcKEiMbFhhaGNgTMAxsF9kP9SP4EBwNyBNjCTMMJAsSCRIB
nA9zCk0KRAPoAWsB6QPYBYL/RwWTAtAAuAIeAagBqADTBuj6HwU0//8FUP+WARQCQgCVCxD+0gJZ9o0BI/8fAKUCwfmkBCn/kv/7
/4P/FQD+AHEDnv5HAOH9PAAiAKwA8PcGBtT96P+oAMMA0v7w/AoWj+iVBKj/sAEq/HoFxwEc7tQQj/tYAOT94gPJ+fgAegFw/F4A
ZxeRFiEYCxjZGWgXtRfhF9gQFhLqDysRywsaElwSRRFECbgIuglkC2YObAibCuAJFAOgAvYCnQJ+AnQEKAK1AyQBlgOuAdMBoQIL
AakEbAESAr7+EALHADQBdQLs/2ECwQDAACsAzgDZAAEB4wG+AHv/TADS/9n/n/+vAAQAaADg/zYA1P9MAOv/kv5NAJn/GAAN/1YB
1/1fANv+kgGe//f/YQBC/5QBKf/PAOb+PQDx//L/OgAk//z/iP9sANP/
```

## Commands

All paths below are relative to the workspace or to `test/scratch/amm-challenge` as indicated. The working checkout and state were under `test/scratch/`.

```sh
pwd; rg --files -g '!test/scratch/**' | head -40; git status --short
mkdir -p test/scratch
git clone -q https://github.com/benedictbrady/amm-challenge.git test/scratch/amm-challenge
git -C test/scratch/amm-challenge checkout -q 6b6921f8d463314aa7c96234e1be25a25245f704
git clone -q https://github.com/gtmcknight/amm-sim.git test/scratch/amm-sim
git -C test/scratch/amm-sim checkout -q 4812a6382311624e1506aca131ca35c378f930d9
curl -LsSf https://api.imd.fun/artifacts/8a6e303b662e1a5ea9bb47f31acedd3988ef65b3ddb66d074517aa59ad41ca40 -o test/scratch/Q.md
curl -LsSf https://api.imd.fun/artifacts/17d249ab0c33fc44931d9b105cf3f9e3846a560bd518b67310c2a56defacdecc -o test/scratch/D.md
rg -n '^## |sha256|qmref|blob' test/scratch/Q.md | head -70
rg --files test/scratch/amm-sim/research/solved test/scratch/amm-challenge | head -65
rg -n '^## |^# |mixture|posterior|arb|retail' test/scratch/amm-sim/research/solved/README.md | head -75
```

Saved the brief's exact setup script at `test/scratch/amm-challenge/scratch/setup.sh`, then ran these from the checkout root:

```sh
mkdir -p scratch
cp ../amm-sim/research/solved/{replica2.py,gates.py,real.py,qm_k1e-5.json,pol_mid.json} scratch/
sh scratch/setup.sh
cp ../amm-sim/research/solved/{evalpol.py,latt.py} scratch/
cd scratch && python3 -I gates.py
```

The extraction command used Python `re` to take the `Strategy.sol` and Python reference fences from `Q.md`, and `base64.b64decode` on the `## Data` fence from `D.md`; it wrote `qmref.py`, `mix.py` and `blob.bin` to checkout `scratch/`. SHA-256 checks: Solidity source including its trailing newline `c68887cff61180e12ba2b1ceb333edf76a830f91f63b5d775a8806fb9ec08aca`; decoded blob `3ac7cb8811ecfb6a17f499aa4e9b70dd55f7fb6432b3aec3b904e11a3dece38e`. Baseline `qmref` edges for seeds 10000..10002 were `443.1017411146794`, `571.454483381923`, `525.908441161234`. The copied `gates.py` printed `443.522608`, `571.623551`, `525.865859` for its Gaussian+qm column.

After editing `mix.py` and the `screen.py` harness in scratch, ran:

```sh
python3 -I screen.py 60000 60015 --workers 8
python3 -I screen.py 60000 60015 --workers 8
python3 -I screen.py 60016 60511 --workers 8
```

The first invocation failed at import before any seed ran; the second completed all 16 seeds. The last completed the remaining 496. A Python aggregation asserted the sorted seed list equals `range(60000, 60512)` and calculated the JSON above. Another `python3 -I` check compared 1,000 randomly selected unchanged-path fee lookups; every fee pair matched qt1 exactly. Source checks:

```sh
curl -LsSf https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/README.md -o test/scratch/TREADME.md
curl -LsSf https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/replica2.py -o test/scratch/Treplica.py
sha256sum test/scratch/TREADME.md test/scratch/amm-sim/research/solved/README.md test/scratch/Treplica.py test/scratch/amm-sim/research/solved/replica2.py
```

## Problems

`python3 -I` initially excluded the scratch directory from `screen.py`'s import path. Adding that path fixed the harness before any seed was evaluated. This item is a Python reference screen; no Solidity implementation, engine gas measurement or fee-parity gate was performed. The variant's worst paired seed in this window is shown in the JSON.