# Glossary

Source: https://docs.tradefloor.dev/glossary.html

> Short definitions of the terms the tradefloor documentation uses, from preset, seed and universe to decision step, tick, fork, manifest and fair value.

The terms these pages use in a specific sense, in alphabetical order. Where another page covers a term in full, its entry links there.

## Agent

Any object with an `act(obs)` method. `tf.evaluate`, `tf.rank` and the other harnesses call it at each decision step. It returns the orders to send as a dict of ticker to shares, or `None` to send nothing. An LLM agent is a model wrapped by one of the [LLM adapters](https://docs.tradefloor.dev/llm-adapters.html).

## Arrow table

The format of a run's output tables, such as `engine.bars()` and `engine.truth()`. pandas, polars, pyarrow and duckdb read them without copying, and tradefloor doesn't depend on any of them. Value columns are float64, and a missing value is NaN.

## Basis point

One hundredth of one percent, written bps. A trade's impact is reported in basis points.

## Decision step

One call of an agent's `act`. `tf.evaluate` makes six a day by default (`steps_per_day=6`), each 65 ticks apart, so 20 days are 120 steps. `obs.step` counts steps over the whole run and `obs.step_of_day` starts again at 0 each day.

## Default preset

The preset a market runs on when you don't name one. It is pt-v22 in tradefloor 0.11.0. It can change between minor releases, so name the preset in any result you publish.

## Engine

`tf.Engine`, the object that runs one market forward through time. It is built from a seed, a universe, the economy on day zero and a preset.

## Fair value

What a company is worth on its earnings or book value, priced at its sector's valuation and the day's interest rates. The traded price is pulled back toward it. On pt-v22 news and market shocks also move fair value itself, mostly for good. `engine.truth()` reports it for every company at every tick, and [How prices are made](https://docs.tradefloor.dev/how-prices-are-made.html#fair-value) gives the model.

## Fingerprint

A short hash that identifies one input. `universe.fingerprint` is a sha256 of the roster, order included. A model's fingerprint is the preset's name when its coefficients are exactly that preset's, and `custom-` with eight hex digits otherwise. A strategy built from a `tf.StrategySpec` has a fingerprint too, and a hand-written agent has none.

## Fork

A copy of a running market that then runs separately. `tf.branch(engine, 2)` makes two copies in memory that share their past bit for bit. Any difference between them afterwards comes from whatever you changed in one. A `tf.Checkpoint` saves a market to a file and rebuilds it later in another process. [Forks and counterfactuals](https://docs.tradefloor.dev/api-counterfactual.html#checkpoints-and-forks) covers both, with the calls for comparing two copies.

## Impact

How far an agent's trades moved the prices of what it traded, in basis points, against that market run with nobody trading. The scorecard weights it by the money traded in each company. A positive value means the move cost the agent.

## Manifest

A `tf.RunManifest`: one JSON file that records the package version, the preset and its coefficients, the seed, the universe, the economy on day zero, any scenario and the order log, with a digest of the finished market. `reproduce()` replays it and raises an error naming the part that disagrees, as [Saving a run](https://docs.tradefloor.dev/reproducibility.html#saving-a-run) shows.

## Mispricing

The log gap between a company's price and its fair value, the column `mispricing_s` in `engine.truth()`. The eleven factor columns beside it add up to its change at every tick.

## Order book

The bids and offers waiting at each price for one company. An agent's orders fill against its depth, so a large order fills at worse prices than a small one and moves the price.

## Order log

`engine.order_log`, the list of every input the engine has consumed, agent orders included. `tf.replay(log, seed=..., universe=...)` rebuilds the market from it.

## Preset

A named, frozen set of model coefficients, such as pt-v22. Choose one with `model="pt-v19"` on `tf.Engine` or `tf.evaluate`. A market on a named preset replays in later releases, since shipped presets don't change. [Reproducibility](https://docs.tradefloor.dev/reproducibility.html#preset-names-and-preset-values) says what a name pins, and [Default market model](https://docs.tradefloor.dev/default-model.html) lists all the presets.

## Reference agents

The five agents `tf.reference_agents()` returns, for scoring your own against on the same market: `buy_and_hold`, `random`, `momentum`, `mean_reversion` and `oracle`. `tf.baselines.BuyAndHold` buys every company in equal weight at its first decision step and never trades again. `tf.versus_buy_and_hold(scores)` gives each agent's P&L minus buy-and-hold's. The oracle reads the model's hidden fair value, and its scorecard says so.

## Release checks

The known-answer tests. Each release runs fixed simulations on all five wheel targets, hashes the results, and compares the hashes with each other and with the committed ones. Any difference stops the release. [Support policy](https://docs.tradefloor.dev/support.html#release-checks) lists the runs.

## Scenario

A file of changes to apply to a market on given days, such as a rate rise or an oil shock, kept apart from the knock-on effects you assume follow from it. Seven ship with the package, and `tf.Scenario.load("liquidity_crisis")` loads one. [Scenarios](https://docs.tradefloor.dev/api-scenario.html) covers writing your own.

## Scorecard

What `tf.evaluate` returns for each agent: its P&L, return, `trades` (the number of fills), impact, risk figures and any errors. [Understand the result](https://docs.tradefloor.dev/quickstart.html#understand-the-result) explains each field.

## Seed

The integer that fixes every random draw a market takes, from 0 to `2**64 - 1`. `tf.Engine(seed=...)` seeds the market, and `Universe.random(n, seed=...)` seeds the companies with a separate seed. Any seed below `2**32` gives the market it gave before 0.8.5.

## Tick

One minute of simulated trading time. A trading day has 390 ticks, and `engine.truth()` has one row per company per tick.

## Transcript

A recording of an LLM agent's model calls and answers, written by the [LLM adapters](https://docs.tradefloor.dev/llm-adapters.html). A replay feeds the answers back without calling the model, so the run repeats exactly.

## Universe

The list of companies a market trades, in order. `tf.Universe.random(n, seed=...)` makes made-up companies, and `tf.Universe.from_edgar(...)` builds them from SEC filings. The same companies in another order make a different market.

## Validated scope

The conditions the realism measurements cover: runs of up to one year (252 trading days) on a roster balanced across sectors, on the default preset. `tf.envelope.check()` refuses a question outside it and says why. [How it is measured](https://docs.tradefloor.dev/how-its-measured.html#the-one-year-table) gives the measurements.

## Warm-up history

Days the market runs before day 0 with nobody trading, so an agent that needs past prices has them at its first decision. Ask for them with `history_days=N` on `tf.evaluate` or `tf.rank`, and read them from `obs.history`, as [Missing warm-up history](https://docs.tradefloor.dev/troubleshooting.html#missing-warm-up-history) describes.
