# fixed-net: fixed-point MLP compression of plain tables

## Method

**Chosen: 4→32→32→1 ReLU MLP, int16 weights, 2,730 bytes including axes. Report-set loss = -0.039742192, SE = 0.010629156, n = 2,048.** Negative loss means the decoded policy earns more edge than the full-table policy. This is a replica compression result, not a Solidity or engine performance claim.

Credit: **Taylor (gtmcknight)** for the solved policy, tables, replica, and Gaussian reference. All upstream files were used at commit `4812a6382311624e1506aca131ca35c378f930d9`. Read the [solved README](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/README.md) first; the authoritative inputs are [pol_mid.json](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/pol_mid.json), [real.py](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/real.py), [evalpol.py](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/evalpol.py), and [replica2.py](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/replica2.py). Measurements below are local experiments using those pinned files and the supplied payload/decoder; they are not upstream performance claims.

Original `pol_mid.json` SHA256: `efbb5ee102db4d312f64565d9bf7232b6becbe02b624164f744a402bbbf2983b`.

### Table inventory

Computed directly from the pinned JSON. All offsets and displacements are in bps.

| Table | Shape (w × R) | Minimum | Maximum |
|---|---:|---:|---:|
| A0 | 321 × 13 | -24.262 | 800.000 |
| B0 | 321 × 13 | -24.262 | 800.000 |
| A1 | 321 × 49 | -31.323 | 800.000 |
| B1 | 321 × 49 | -31.323 | 800.000 |
| A2 | 321 × 49 | -31.333 | 800.000 |
| B2 | 321 × 49 | -31.333 | 800.000 |

There are 71,262 offset entries. Every table has 321 w rows, `w = (row−160)×5`, from −800 to +800 in 5 bps steps. Phase 0 has 13 R columns from −30 to +30 in 5 bps steps. Phases 1 and 2 have 49 R columns, `R = 5×W2L[column]`, with nonuniform spacing. In bps these are:

```text
-800 -650 -500 -400 -300 -250 -200 -150 -125 -100 -85 -70 -60 -55
-50 -45 -40 -35 -30 -25 -20 -15 -10 -5 0 5 10 15 20 25 30 35 40
45 50 55 60 70 85 100 125 150 200 250 300 400 500 650 800
```

Adjacent differences in that list are the exact column grid steps. Phase is discrete 0/1/2. There is no sd axis in the plain tables: [the reference bypasses sd when Q is absent](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/real.py). The network nevertheless has four input slots `(w, R, phase, sd)`; all sd weights are explicitly zero. In the full JSON, every `B[phase][i][j]` equals `A[phase][320−i][ncol−1−j]` exactly (maximum discrepancy 0). Train one ask predictor and obtain bids by reflection. `VD0` and `VD1` are solver value diagnostics, not offset tables; they are not reconstructed or used by plain `real.py`. The decoder returns all six offset tables and all scalar/grid metadata that the plain reference consumes.

### Training and integer verification

Local training used NumPy 2.5.4 and PyTorch CPU 2.15.0+cpu, one torch thread. Input order is `(w/100, R/100, phase, 0)`, target `A/100`, float32 MSE, Adam default options, minibatches of 2,048 sampled with replacement. Each phase has total sampling probability 1/3; within a phase each grid cell is weighted by `(0.02+exp(−abs(w)/70))×(0.02+exp(−abs(R)/70))`. Rows are flattened in row-major order, phases 0 then 1 then 2. Sampling probabilities are normalized per phase, then globally.

For the chosen width 32 model: `torch.manual_seed(135)`, `numpy.random.seed(132)`, standard `Linear(4,32), ReLU, Linear(32,32), ReLU, Linear(32,1)` initialization; then overwrite neuron 0 in each hidden layer to pass `ReLU(w/100)` unchanged and set its output weight to 1. Freeze just those two weight rows, their biases, and that output weight. Other parameters remain trainable. Train 150,000 updates with `lr = 0.001 × 0.1**(update/150000)`, update starting at zero. This fixed path is part of the ordinary MLP, not an additional lookup or representation.

Export weights by nearest-even rounding to each layer's fixed-point scale, biases to the corresponding accumulator scale. Start with shift 12 and reduce a layer's shift until int16 weights and int32 biases fit, without clipping. The chosen shifts are **12, 10, 12**. Set sd input weights to zero on export. All scoring uses the integer forward pass after this export, never floating-point network outputs. The complete decoded offset grid has an exact scalar/vector agreement check on 1,500 random cells (500 per phase, independent scalar `struct` reader, seed 8901). Across all grid inputs the maximum absolute pre-shift accumulator by layer is 1,044,416,228; 2,768,536,642; 540,496,130. Thus signed 32-bit accumulation is insufficient; Python uses int64 and a Solidity implementation should use signed 256-bit arithmetic.

### Gate P, before compression work

Unmodified `python3 -I gates.py` reproduced [the reference gates](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/gates.py) and the README values to every printed digit:

| Seed | Perfect information | 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 |

## Encoding

The Data block below decodes to exactly **2,730 bytes**, all data needed for the learned lookup, including the irregular R knots. No entropy codec, float weights, external model, correction table, or submodule is required.

| Offset | Length | Meaning |
|---:|---:|---|
| 0 | 1 | uint8 hidden width h = 32 |
| 1 | 3 | uint8 layer shifts: 12, 10, 12 |
| 4 | 98 | 49 little-endian signed int16 W2L coordinates, in units of 5 bps |
| 102 | 256 | Layer 0 weights, int16 LE, shape 32×4, output-major row order |
| 358 | 128 | Layer 0 biases, signed int32 LE, 32 elements |
| 486 | 2,048 | Layer 1 weights, int16 LE, shape 32×32 |
| 2,534 | 128 | Layer 1 biases, signed int32 LE, 32 elements |
| 2,662 | 64 | Layer 2 weights, int16 LE, shape 1×32 |
| 2,726 | 4 | Layer 2 bias, signed int32 LE |

For width h with one output, total bytes = `2h² + 18h + 106`. Weights have scale `2**shift`; activations have scale `2**14`. Biases have scale `2**(14+shift)` and are already in accumulator units.

For an integer grid coordinate pair, form `x = nearest_even(16384×[w/100,R/100,phase,0])`. For each layer: `z[j] = floor((bias[j] + Σ weight[j,i]×x[i]) / 2**shift)`. Apply `max(0,z)` after each hidden layer only. Final ask offset = `100×z[0]/16384` bps. An arithmetic right shift implements the floor rule; Solidity signed division truncates toward zero and is **not** interchangeable for a negative final accumulator. Input rounding is nearest-even, not truncation.

To reproduce the scored policy, evaluate the MLP at the four grid corners for ask and the four reflected corners for bid, then use exactly Taylor's bilinear interpolation, grid clamping and fee conversion in [DPPolicy._fees](https://raw.githubusercontent.com/gtmcknight/amm-sim/4812a6382311624e1506aca131ca35c378f930d9/research/solved/evalpol.py). Do not substitute a continuous-state MLP evaluation: that is a different policy. Phase and sd have no interpolation axis here. The decoder's grid construction makes input rounding unambiguous.

## Tradeoff

All seven settings below were scored on **the same seeds 60000..61023, n=1,024**, against the same full-table run. Loss is the mean of `full_edge − decoded_edge` per seed. SE uses sample variance divided by n. Choose the lowest mean loss; no report-set decoded scores were evaluated until that choice and its payload hash were locked.

| Setting | Bytes, including axes/header | Choose-set loss | SE |
|---|---:|---:|---:|
| 16×16; 30k updates, constant LR | 906 | 0.351053120 | 0.016554603 |
| 24×24; 100k updates, constant LR | 1690 | 0.281773385 | 0.014280382 |
| 32×32; 150k updates, decaying LR | 2730 | 0.246807199 | 0.015961022 |
| 24×24; 100k + 50k refinement | 1690 | 0.172467132 | 0.014762306 |
| 32×32; 150k, fixed positive-w path **chosen** | 2730 | -0.056134271 | 0.015645435 |
| 32×32; 120k, three phase output heads | 2866 | 0.019048078 | 0.014389945 |
| 32×32; 120k, diagonal sampling/input basis | 2730 | 0.301765564 | 0.015335929 |

Constant LR means 0.001. Decaying LR means `0.001×0.1**(update/updates)`. The 24-unit refinement starts from its 100k constant-LR weights and adds 50k updates with `0.0003×0.1**(update/50000)`. Baseline torch/NumPy seeds are `103+width` / `100+width`. The three-head variant is the same MLP with three linear output neurons and selects the phase's output; its extra 136 bytes are included. It was not chosen. The diagonal variant trains with second input `(R−w)/100`, absorbs that linear change into the exported first layer, and uses `R−w` instead of R in the sampling factor for phases 1/2. No other compressed representation was tested.

## Chosen

**32skip: two hidden layers of 32, one scalar output, int16 weights, Q14 activations, shifts (12,10,12), 2,730 bytes.** On report seeds **10000..12047**, evaluated after selection:

- Paired loss, full minus decoded: **-0.039742192**.
- SE: **0.010629156**; **n = 2,048**.
- Full-table mean edge: **532.385686971**.
- Decoded-table mean edge: **532.425429163**.
- Both requested targets are met: 2,730 < 12,288 bytes and mean loss < 0.2.

Worst five seeds, sorted by largest positive loss (not by lowest raw edge):

| Seed | Full edge | Decoded edge | Full − decoded |
|---|---:|---:|---:|
| 10632 | 693.738514195 | 689.982124361 | 3.756389833 |
| 11701 | 659.900967937 | 656.701377993 | 3.199589945 |
| 10822 | 760.660011206 | 758.636918851 | 2.023092355 |
| 10735 | 558.244123355 | 556.578413735 | 1.665709620 |
| 11705 | 642.372088335 | 640.938110678 | 1.433977657 |

The report policy uses Gaussian `plain:soft=1` throughout, not perfect information or qm. Replica runs use the reference's default 10,000 steps and its per-seed randomized parameters. Scores are not engine scores, and the SE does not account for choose-set model selection.

## Lookup cost

For one scalar grid-corner prediction with h=32: **1,184 integer multiplies and 1,184 accumulator additions**, 65 arithmetic rescalings, 64 ReLU comparisons. This includes all four input slots; the zero sd column could be skipped by an optimized implementation. Read 1,184 int16 weights and 65 int32 biases = **2,628 byte reads**, plus the shared four-byte header. Counting byte accesses is not counting EVM opcodes or gas.

A scored ask/bid lookup using bilinear interpolation needs **eight forward passes**, because bids use reflected inputs: **9,472 multiplies, 9,472 additions, 520 rescalings, 512 ReLUs, and 21,024 learned-data byte accesses** without caching. Add header/grid reads, grid search and coordinate rounding, and bilinear interpolation (12 multiplies, six additions, shared fractions). Binary search over 49 R knots is logarithmic. Grid/header data occupy another 102 bytes and may be cached; this is not a claim that all 102 are reread each time. Gaussian filtering, logs, exponentials, fee conversion, loops, indexing and sign extension are additional costs. Direct continuous inference would need only two forward passes but has not been scored or validated here.

## Decoder

One standalone function; 31 lines; standard library plus NumPy only. Returns a dictionary in the format plain `real.py` loads. The row/column arrays are generated from integer inference, not from the original tables.

```python
def decode_fixed_net(data):
    """Decode the fixed-net payload to a dict accepted by real.py/plain."""
    import numpy as np
    data = bytes(data)
    h = data[0]
    if not 8 <= h <= 32 or len(data) != 2*h*h + 18*h + 106:
        raise ValueError('invalid fixed-net payload')
    rgrid = np.frombuffer(data, '<i2', 49, 4).astype(int).tolist()
    layers, at = [], 102
    for ni, no in ((4, h), (h, h), (h, 1)):
        n = ni * no
        w = np.frombuffer(data, '<i2', n, at).astype(np.int64).reshape(no, ni)
        at += 2*n
        b = np.frombuffer(data, '<i4', no, at).astype(np.int64)
        at += 4*no
        layers.append((w, b, data[1+len(layers)]))
    out = dict(g=0.05368206098114493, lam=0.8, sigma=9.45, size=20.0,
               H_bps=5.0, NW=321, W0=160, N2=49, C2=24, FB=6, W2L=rgrid)
    for phase in range(3):
        r = np.arange(-30, 31, 5) if phase == 0 else np.array(rgrid)*5
        w, rr = np.meshgrid(np.arange(-800, 801, 5), r, indexing='ij')
        x = np.stack((w/100, rr/100, np.full_like(w, phase), w*0), axis=-1)
        x = np.rint(x.reshape(-1, 4)*16384).astype(np.int64)
        for k, (weight, bias, shift) in enumerate(layers):
            x = (x @ weight.T + bias) // (1 << shift)
            if k < 2:
                x = np.maximum(x, 0)
        a = x.reshape(w.shape)*100/16384
        out['A'+str(phase)] = a.tolist()
        out['B'+str(phase)] = a[::-1, ::-1].tolist()
    return out
```

Example, after saving the function as `decoder.py` and the Data block as `model.b64`:

```python
import base64, json
from decoder import decode_fixed_net
payload = base64.b64decode(open('model.b64').read(), validate=False)
tables = decode_fixed_net(payload)
with open('decoded.json', 'w') as f:
    json.dump(tables, f, separators=(',', ':'), sort_keys=True)
```

Canonical decoded JSON (UTF-8, `json.dumps(tables,separators=(',',':'),sort_keys=True)`): **1,134,669 bytes**, SHA256 `068ee67f3219df2aaf9ab9f8e93d29dc79ad313afa17771d818f062609a1cec6`. This checksum covers all six decoded tables and metadata, and identifies the exact values used for scoring.

### Reproduce paired scoring

Run Taylor's files with plain `python3 -I`, from the pinned `research/solved` directory. His CLI names match the README and brief:

```sh
python3 -I gates.py
python3 -I real.py pol_mid.json plain:soft=1
python3 -I real.py /path/to/decoded.json plain:soft=1
```

Both report CLI commands were also run independently. The CLI hardcodes a seed start of 10000 and does not retain per-seed rows; for choose-set scoring and paired per-seed statistics, use this standalone driver, which calls the unmodified `real.ev` API. No replica source changes or third-party dependencies are needed. Save it as `score_pair.py` in the working research directory:

```python
import os, sys, math, multiprocessing as mp
sys.path.insert(0, os.getcwd())  # run from the pinned research/solved folder
import real

def score(pool, path, seeds):
    tasks = [(path, {'soft': 1.0}, seeds[i:i+4])
             for i in range(0, len(seeds), 4)]
    return {row[0]: row[1] for batch in pool.map(real.ev, tasks) for row in batch}

if __name__ == '__main__':
    original, decoded, start, n = sys.argv[1:]
    start, n = int(start), int(n)
    seeds = list(range(start, start+n))
    with mp.Pool(12) as pool:
        a = score(pool, original, seeds)
        b = score(pool, decoded, seeds)
    d = [(s, a[s]-b[s]) for s in seeds]
    mean = sum(v for s, v in d)/n
    se = math.sqrt(sum((v-mean)**2 for s, v in d)/(n-1)/n)
    print('n, loss, se:', n, mean, se)
    for s, loss in sorted(d, key=lambda row: -row[1])[:5]:
        print(s, a[s], b[s], loss)
```

```sh
python3 -I score_pair.py pol_mid.json /path/to/decoded.json 60000 1024
python3 -I score_pair.py pol_mid.json /path/to/decoded.json 10000 2048
```

The second command is for reproducing this locked choice, not selecting a new model. Loss is relative to the full tables, not relative to HA. Local work was segmented into commands of less than eight minutes; scratch files are not runtime dependencies.

## Data

Payload SHA256: `9727ecc8acf6d31732793d1836c60cd637133b800bbe61b19098bfee7d17e0f6`. Decoded size **2,730 bytes**; base64 length **3640 characters**, excluding line breaks. This payload is normative; no training dependency is needed to regenerate the decoded tables.

```base64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```

## Problems

- Gate P passed; Gate Q uses the exact shipped integer-decoded values. The requested Solidity callback parity Gate F was **not run**: this bounded item delivers network compression and a decoder, not a Strategy contract.
- No Solidity bytecode size, afterSwap gas, OutOfGas rate, `amm_sim_rs.gas_stats()`, or engine/t03 paired results were measured. No engine seed was consumed. The eight-pass interpolated lookup is substantial work; the 245,000-gas cap remains unproven. A merge must implement and measure it before claiming the overall strategy goal is met.
- Do not replace the eight corner predictions by continuous network inference and inherit these scores. Such a change needs separate paired scoring and callback parity checks.
- Only six plain offset tables are compressed. qm uncertainty tables and solver value diagnostics are outside this representation. The decoded grid need not equal the full grid pointwise; its policy performance is established only by the paired replica measurement above.