the formal companion. longer, drier, and complete.
the front page tells the story the way a visitor needs it told. this page is the other register: the one a reader opens because they intend to check something, to build against the cell, or to find the sentence that survives an argument. nothing here contradicts the front page and nothing here is softer than it. it fixes notation, walks the meters, states the storage layout word by word, quantifies who could lean on the measurement and by how much, prices the crank, follows every unit of value, and ends with the procedure by which a stranger reproduces the entire record without asking anyone's permission.
notation first. a run is indexed k, starting from zero. in(k) and out(k) are that run's metered input and output in the chain's smallest unit. b(k) is the baseline ratio in force when run k settles, expected(k) is b(k) times in(k), and the filed residue is out(k) minus expected(k), over expected(k), in basis points with its sign. L is the lattice balance over total supply, and the distribution multiplier is L to the fourth power. every claim on this page is a statement about those integers and the five functions allowed to touch them, because nothing else exists.
the meters are not estimates. the cell is a hook, so the pool itself calls it on every swap with the amounts already settled; the cell adds them to two accumulators and returns. there is no oracle, no indexer, no sampling, and no path by which a trade reaches the pool without crossing the meter. the accumulators are two storage words, and the gas cost of metering is flat per swap whatever the market is doing, which is why the instrument can promise to be total rather than statistical.
the storage is small enough to audit by hand: eight words of config fixed at deployment, four words of accumulators, three words for the baseline, the run counter, and the open run's timestamp, then one packed word per settled run, forever. the config words hold the run length of 21600 seconds, the smoothing denominator of 8, the bounty of half a percent, the loading exponent of 4, and the addresses the cell is married to. there is no proxy, no owner slot, and no function that writes to config after construction; a reader can verify the absence in the bytecode rather than take it on faith.
the baseline arithmetic is exact integer arithmetic, and its bias is stated rather than hidden. the update folds each run's ratio into the average with denominator eight, rounding toward zero at each step; rounding toward zero means the baseline drifts a fraction of one smallest unit low rather than high, which makes the instrument's one systematic error conservative: it can only ever flatter the null verdict, never the excess one. an instrument that errs, errs against its own headline. that choice is the whole of the experiment's epistemology compressed into a rounding mode.
who can lean on the needle deserves the same candor. the deployer cannot: there is no key. depositors cannot: loading changes the split of output, not the metering of it. a trader can raise in(k) by trading, which raises the expectation proportionally and gains nothing. the residual party is a settler who times the crank, because settling early or late moves a run's boundary; the contract clamps this by refusing to settle before the run length has elapsed, so the crank can stretch a run but never shorten one, and a stretched run folds more history into both meters symmetrically. the lean that remains is real, bounded, and visible in the filed timestamps, where anyone can measure it.
the crank is priced, not trusted. half a percent of a run's metered fees goes to whoever settles it, paid from the same flow it measures, so the job funds itself exactly when there is something to file and pays nothing when there is nothing to say. if the bounty is ever too small to interest anyone, the run waits without loss; the meters keep integrating, and the eventual settlement folds the whole quiet stretch into one honest row. the experiment can hibernate for a year and wake up correct.
every unit of value has one path. swap fees flow into the cell, and at settlement the run's output is split by the loading law: the lattice's share is distributed pro rata to depositors, and the remainder stays in the cell's reserve, where it sits until the loading law releases more of it to a better loaded future. the bounty is carved from the run's fees before the split. deposits and withdrawals move only the depositor's own supply. the deployer receives nothing, there is no treasury address, and no function's destination is chosen by its caller.
the factory deploys replications with the same bytecode and the same config words, at addresses computed deterministically from the registry index, so a skeptic can state in advance exactly what will exist and where, and verify afterward, byte for byte, that it does. the registry is append only. a replication cannot be delisted, and its record cannot be separated from the original's; the two tables on the front page are read from the same array. replication was the instrument that judged the original experiment, and it worked even though it was improvised. here it is enforced by construction, which is the one improvement this project claims.
what remains is the reproduction. fetch the cell's events for any run and re add the meters; the sums must equal the filed row to the smallest unit. start from the genesis baseline and fold every filed ratio through the smoothing arithmetic with its stated rounding; every expectation must reproduce exactly. recompute every residue and every verdict. compute the factory's addresses and confirm every replication is byte identical. any mismatch anywhere, by one unit, would be proof of a broken instrument, printable on one line. none will be found, and that sentence is falsifiable, which is the entire reason this page exists.