# combo-fees: TwoComp filter + weighted-average fee quoting (replica screen)

Credit: Taylor (gtmcknight) for the Gaussian filter, the solved qm tables, real.py's fee rule and the replica ([amm-sim research/solved @4812a638](https://github.com/gtmcknight/amm-sim/tree/4812a6382311624e1506aca131ca35c378f930d9/research/solved)); qt1's reference from [K](https://raw.githubusercontent.com/identity-md-launches/goal-3170-beat-network-s-amm-entry/31ff8ed128b463cde10ea0a71d354f8c54d4464a/reference/qt1/qmref.py); TwoComp from [TC](https://api.imd.fun/artifacts/d3c849db2ac31e567b57e52b80b86e8c24c842e5b4125b9d75c78e3cb07115b9); the quoting rule from [MIX](https://api.imd.fun/artifacts/23cf289cf15eff6790cb2067a714df9d020049d2de5f3975c11857ab344cb9e4).

**Headline (replica, not engine):** COMBO − qt1-ref = **+0.6376 (se 0.0195)** on choose 60000..61023 and **+0.5986 (se 0.0134)** on report 10000..12047. COMBO − TwoComp = +0.1922 (se 0.0147) / +0.1738 (se 0.0108). Both windows complete (n=1024, n=2048). Nothing tuned.

## Exact rule

- Filter and state are TwoComp's, unchanged (`DUAL_CUTS=2`): at a step's first callback (`dt>=1`) each component gets diffusion and up to two separate silent-step no-arb cuts, after which they are merged by moment matching; arb likelihood `la = sum w·N(lp; m, v)`, retail mass `Z = sum w·z`, retail moments `(mt, vt)` = moment match of the truncated components, `pi = la/(la+lr)`; carried posterior `comp = [(pi, lp, 0), (1-pi, mt, vt)]` if `.005<pi<.995`, else the single winning component; `m, v` = mixture moments; rival estimate, synced, cnt, tlast as in TwoComp/qt1.
- Quoting: only when `dt>=1` and `.005<pi<.995` (ambiguous first trade), the returned fees are MIX's: arb branch: rival `ra = clip(s2h, exp(lp)·.997, exp(lp)/.997)`, `synced=False`, `(fb_a, fa_a) = lookup((ln s − lp)·1e4, (ln ra − lp)·1e4, phase 0, sd 0)`. Retail branch: `rr = clip(s2h, exp(mt)·.997, exp(mt)/.997)`, then qt1's directional rival update with the incoming fee (`cand = s(1−fb)/.997` on buy, `s·.997/(1−fa)` on sell; replaces `rr` and sets synced if it improves), `(fb_r, fa_r) = lookup((ln s − mt)·1e4, (ln rr − mt)·1e4, phase 1, sqrt(vt)·1e4)`. Return per side `pi·fee_arb + (1−pi)·fee_ret`; `synced` restored before the state update. One paired lookup per branch (2 paired = 4 scalar sides). The branches are exactly TwoComp's own two components (pi, lp, 0) and (1−pi, mt, vt).
- All other callbacks quote as TwoComp (one lookup on mixture mean/sd). The returned fee (clipped to [0, 0.1]) becomes the stored `fb, fa`.

## Gate P and qt1-ref check

- Gate P: `python3 -I gates.py` in research/solved @4812a638 printed, identical to its README `## Gates` table:
```
seed   perfect-info      gaussian+plain    gaussian+qm       lattice+qm
10000  448.261189  443.455598  443.522608  443.663520
10001  576.779199  571.463409  571.623551  571.977293
10002  531.886497  525.168028  525.865859  526.411631
```
- blob.bin from K: 10,167 bytes, sha256 `3ac7cb8811ecfb6a17f499aa4e9b70dd55f7fb6432b3aec3b904e11a3dece38e`. `qmref.QMRef('blob.bin')` via `replica2.run` gave 443.101741 / 571.454483 / 525.908441 on 10000..10002 (match).
- vs published edges: **PR (10000..12047): all 2048 seeds equal to 6 dp.** **PC (60000..61023): 1007 of 1024 equal, 17 differ** (by 0.001–0.05 edge; e.g. 60027 mine 610.629390 vs PC 610.588587; 60074 375.830750 vs 375.879165). Re-running 60027/60074 alone reproduced my values exactly (deterministic). Its first 8 seeds 60000..60007 match. Because PC does not hold on every seed, **I recomputed qt1-ref myself on every seed of both windows and paired against my own recomputation**; the list of 17 mismatches is in the choose JSON. (Pairing against PC instead gives COMBO−qt1 +0.637579 se 0.019545, TwoComp−qt1 +0.445421 — differences ≤ 4e-6.) I did not investigate why PC differs on those seeds.
- TwoComp edges on 10000..10002: **443.690614 / 571.968071 / 526.124475**. TwoComp − qt1 on the report window (+0.424803, se 0.012202) and mean edges equal TC's published report figures (+0.424802883, 533.687633550 / 533.262830667), so the TC block is reproduced.

## Screen JSON

Each seed was run once per policy (qt1-ref, TwoComp, COMBO); diffs are first minus second; se = sample sd/√n; worst5 = five lowest diffs. `seconds_per_seed_1core` is the mean per-run wall time inside a worker; this machine's cgroup gives 1 CPU (cpu.max 100000/100000) and runs used 2–14 processes sharing it, so these are inflated by contention: a solo run measured ~0.35–0.40 s for COMBO after table decode (~1.8 s per process). `new_path_callbacks_per_run_COMBO` = mean count of ambiguous-first-trade callbacks quoted by the weighted rule per 10,000-step run.

### choose 60000..61023
```json
{
 "COMBO-qt1": {
  "n": 1024,
  "mean_diff": 0.637582,
  "se": 0.019547,
  "worst5": [
   [
    60210,
    -2.92036
   ],
   [
    60036,
    -1.628106
   ],
   [
    60326,
    -1.439533
   ],
   [
    60446,
    -1.096306
   ],
   [
    60936,
    -1.073614
   ]
  ]
 },
 "TwoComp-qt1": {
  "n": 1024,
  "mean_diff": 0.445424,
  "se": 0.017637,
  "worst5": [
   [
    60733,
    -1.159273
   ],
   [
    60728,
    -1.144837
   ],
   [
    60446,
    -1.049882
   ],
   [
    60326,
    -0.957574
   ],
   [
    60143,
    -0.884082
   ]
  ]
 },
 "COMBO-TwoComp": {
  "n": 1024,
  "mean_diff": 0.192158,
  "se": 0.014701,
  "worst5": [
   [
    60210,
    -3.253952
   ],
   [
    60385,
    -1.88546
   ],
   [
    60927,
    -1.291321
   ],
   [
    60408,
    -1.232461
   ],
   [
    60268,
    -1.116206
   ]
  ]
 },
 "mean_edge": {
  "qt1_ref": 529.971157,
  "TwoComp": 530.416581,
  "COMBO": 530.608739
 },
 "seconds_per_seed_1core": {
  "qt1": 2.1874,
  "tc": 2.4388,
  "combo": 3.0624
 },
 "new_path_callbacks_per_run_COMBO": 5861.19,
 "qt1_ref_vs_published_mismatch": {
  "n": 17,
  "seeds": [
   [
    60027,
    610.62939,
    610.588587
   ],
   [
    60060,
    466.549781,
    466.518326
   ],
   [
    60066,
    515.31258,
    515.30734
   ],
   [
    60074,
    375.83075,
    375.879165
   ],
   [
    60149,
    736.837134,
    736.850677
   ],
   [
    60405,
    654.696195,
    654.717762
   ],
   [
    60427,
    513.186448,
    513.190707
   ],
   [
    60457,
    520.231624,
    520.241417
   ],
   [
    60532,
    597.817514,
    597.808841
   ],
   [
    60587,
    548.213606,
    548.208327
   ],
   [
    60689,
    640.207035,
    640.203386
   ],
   [
    60747,
    599.677589,
    599.675626
   ],
   [
    60839,
    716.663987,
    716.670286
   ],
   [
    60904,
    426.474955,
    426.47144
   ],
   [
    60951,
    515.490225,
    515.489103
   ],
   [
    60988,
    513.435571,
    513.434538
   ],
   [
    61023,
    603.564959,
    603.566722
   ]
  ]
 }
}
```

### report 10000..12047
```json
{
 "COMBO-qt1": {
  "n": 2048,
  "mean_diff": 0.59864,
  "se": 0.013386,
  "worst5": [
   [
    10146,
    -3.535515
   ],
   [
    11062,
    -2.334519
   ],
   [
    11808,
    -1.81974
   ],
   [
    10519,
    -1.783292
   ],
   [
    11376,
    -1.750233
   ]
  ]
 },
 "TwoComp-qt1": {
  "n": 2048,
  "mean_diff": 0.424803,
  "se": 0.012202,
  "worst5": [
   [
    10146,
    -2.751934
   ],
   [
    11701,
    -2.426585
   ],
   [
    11062,
    -1.680672
   ],
   [
    11949,
    -1.220172
   ],
   [
    10394,
    -1.201831
   ]
  ]
 },
 "COMBO-TwoComp": {
  "n": 2048,
  "mean_diff": 0.173837,
  "se": 0.01077,
  "worst5": [
   [
    11695,
    -1.827324
   ],
   [
    10475,
    -1.653549
   ],
   [
    10519,
    -1.44753
   ],
   [
    11376,
    -1.395596
   ],
   [
    11892,
    -1.361368
   ]
  ]
 },
 "mean_edge": {
  "qt1_ref": 533.262831,
  "TwoComp": 533.687634,
  "COMBO": 533.861471
 },
 "seconds_per_seed_1core": {
  "qt1": 2.1943,
  "tc": 2.4849,
  "combo": 2.9793
 },
 "new_path_callbacks_per_run_COMBO": 5873.06,
 "qt1_ref_vs_published_mismatch": {
  "n": 0,
  "seeds": []
 }
}
```

## Code

`combo.py` (stdlib; `Combo('blob.bin')` is a replica2 policy). It imports `twocomp.py`, which is TC's `## Code` block saved verbatim (it contains qt1's reference plus `class TwoComp(QMRef)`).

```python
"""COMBO: TwoComp's two-component filter + wavg-fees quoting at ambiguous first trades.
Credit: Taylor (gtmcknight) for the Gaussian filter, solved tables and replica (amm-sim research/solved);
qt1's reference (qmref) and TwoComp (twocomp.py = TC's Code block, unchanged). Stdlib only.
usage: from combo import Combo; Combo('blob.bin') is a replica2 policy."""
import math
from twocomp import TwoComp, trunc, phi, LD_M, LD_S, MAXF


class Combo(TwoComp):
    def __init__(self, blob_path):
        super().__init__(blob_path)
        self.new_path_calls = 0

    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_fees = None
        if dt >= 1:
            self.cnt = 0
            lo = math.log(self.sp * (1 - self.fb)); hi = math.log(self.sp / (1 - self.fa))
            prior = self.propagate(dt, lo, hi)
            lp = math.log(s * (1 - self.fb)) if is_buy else math.log(s / (1 - self.fa))
            la = 0.0; Z = 0.0; retail = []
            for w, m, v in prior:
                sd = math.sqrt(v)
                la += w * phi((lp - m) / sd) / sd
                z, mt, vt = trunc(m, v, lo, hi)
                Z += w * z
                retail.append((w * z, mt, vt))
            if Z > 1e-300:
                mt, vt = self.moments([(w / Z, m, v) for w, m, v in retail])
            else:
                i = max(range(len(prior)), key=lambda i: prior[i][0])
                _, mt, vt = retail[i]
            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:
                # wavg-fees quoting: one lookup per branch, branches = TwoComp components
                old_synced = self.synced
                pa = math.exp(lp)
                ra = max(pa * .997, min(pa / .997, self.s2h))
                self.synced = False
                fba, faa = self.lookup((math.log(s) - lp) * 1e4, (math.log(ra) - lp) * 1e4, 0, 0.)
                pr = math.exp(mt)
                rr = max(pr * .997, min(pr / .997, self.s2h))
                cand = s * (1 - self.fb) / .997 if is_buy else s * .997 / (1 - self.fa)
                if (cand < rr) if is_buy else (cand > rr):
                    rr = cand; self.synced = True
                fbr, far = self.lookup((math.log(s) - mt) * 1e4, (math.log(rr) - mt) * 1e4,
                                       1, math.sqrt(vt) * 1e4)
                self.synced = old_synced
                mix_fees = (pi * fba + (1 - pi) * fbr, pi * faa + (1 - pi) * far)
                self.new_path_calls += 1
                self.comp = [(pi, lp, 0.), (1 - pi, mt, vt)]
            elif is_arb:
                self.comp = [(1.0, lp, 0.)]
            else:
                self.comp = [(1.0, mt, vt)]
            self.m, self.v = self.moments(self.comp)
            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_fees 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:
            fb, fa = mix_fees
        self.fb, self.fa = min(MAXF, max(0.0, fb)), min(MAXF, max(0.0, fa))
        return fb, fa
```

Screen driver `screen.py` (checkpoints one JSON line per (seed, policy); resumes skipping done pairs):

```python
import sys, json, time, os
from multiprocessing import Pool
H=os.path.dirname(os.path.abspath(__file__)); sys.path[:0]=[H, os.path.join(H,'../dl/T/research/solved')]
import replica2 as R
from qmref import QMRef
from twocomp import TwoComp
from combo import Combo
B=os.path.join(H,'blob.bin')
def run(a):
    seed,pol=a; t0=time.perf_counter()
    P={'qt1':QMRef,'tc':TwoComp,'combo':Combo}[pol](B)
    e=R.run(seed,P)['edge']
    return [seed,pol,e,time.perf_counter()-t0,getattr(P,'new_path_calls',None)]
if __name__=='__main__':
    a,b,pols=int(sys.argv[1]),int(sys.argv[2]),sys.argv[3].split(',')
    out=os.path.join(H,sys.argv[4]); done=set()
    if os.path.exists(out):
        for l in open(out): r=json.loads(l); done.add((r[0],r[1]))
    jobs=[(s,p) for s in range(a,b) for p in pols if (s,p) not in done]
    t0=time.time()
    with Pool(int(sys.argv[5])) as pool, open(out,'a') as f:
        for r in pool.imap_unordered(run,jobs): f.write(json.dumps(r)+'\n'); f.flush()
    print(len(jobs),time.time()-t0)
```

## Commands

```bash
mkdir -p test/scratch/dl && cd test/scratch/dl
git clone https://github.com/gtmcknight/amm-sim T && git -C T checkout 4812a6382311624e1506aca131ca35c378f930d9
for h in <TC> <MIX> <PC> <PR>; do curl -sL https://api.imd.fun/artifacts/$h -o $h; done
curl -sLO <K>/blob.bin; curl -sLO <K>/qmref.py
(cd T/research/solved && python3 -I gates.py)                          # Gate P
# twocomp.py = TC "## Code" python block; PC.json/PR.json = "edges" of the json block in PC/PR
cd ../w   # combo.py, screen.py, blob.bin, qmref.py
python3 -I screen.py 10000 10003 qt1,tc,combo spot.jsonl 9
python3 -I screen.py 60000 61024 tc,combo choose.jsonl 2   # repeated (timeout 470) until complete
python3 -I screen.py 60000 61024 qt1 choose.jsonl 2
python3 -I screen.py 10000 12048 tc,combo report.jsonl 2   # repeated until complete
python3 -I screen.py 10000 12048 qt1 report.jsonl 2
python3 -I s3.py > s2.json                                  # paired stats (both windows checked complete)
```

## Problems

- Replica evidence only: no engine run, no Solidity, no gas or Gate F for COMBO (outside this item). The quote path adds a second paired lookup at ~5,870 callbacks per run on top of TwoComp's filter, whose own gas was only estimated by TC (~239k, not established under the 245k limit); COMBO's gas is likely higher still.
- Published PC disagrees with a deterministic recomputation of qt1-ref on 17 of 1024 seeds (see above); scores here pair against my recomputation.
- seconds_per_seed are contention-inflated on a 1-CPU cgroup (see Screen).
- COMBO worst seeds are worse than TwoComp's (60210: −3.25 vs TwoComp; 10146: −3.54 vs qt1) though the mean gain holds in both windows.