The synthetic company: real data has a price, synthetic data has a method

In August, Google bid $10 million for the corporate records of Spirit Airlines, a carrier in bankruptcy. The lot holds about 100 million emails and 500 million Teams messages, plus spreadsheets, code and operational data. TIME read the bid as a lab buying private white-collar work to build reinforcement-learning environments for agents. Mercor bid $7.5 million. Micro1 offered $12.5 million after the auction closed. The sale still needs a judge. A hearing first set for 19 August has been pushed back several times and is now slated for 30 September.

A year earlier, a security group built the same kind of data from nothing. Chimera, published at NDSS 2026, runs a simulated 20-person company for a month. Language-model agents play the employees and plant 15 insider attacks drawn from real cases. Five security experts rated its logs 4.20 for realism on a five-point scale. Logs recorded from real people scored 4.25. One of its three companies is a team designing a market-neutral statistical arbitrage fund.

Real data has a price. Synthetic data has a method. The price is the easy part to read. It is rising wherever a model learns. Epoch AI puts the stock of usable public human text at about 300 trillion tokens and expects frontier training to use all of it between 2026 and 2032. Ilya Sutskever told NeurIPS in December 2024 that “pre-training as we know it will unquestionably end” (The Verge). Expert data is now priced by the hour. Mercor pays industry experts up to $200 an hour. OpenAI’s Project Mercury was paying more than 100 former investment bankers $150 an hour to write prompts and build financial models, Bloomberg reported in October 2025. Spreadsheet-RL shows the cheaper route for the same kind of work. Its verifier recalculates the agent’s finished workbook in real Excel and pays 1 only when every answer cell matches an oracle workbook. Training a 4B model against it roughly doubles the model’s pass rate on the paper’s finance tasks.

A research house runs short of something else. It runs short of history. AQR’s Can Machines Learn Finance? makes the point with one number: a five-year forecast of market returns over 1926 to 2018 rests on 19 distinct observations. Marcos López de Prado put the cost of reuse at about 20 iterations on the same data before a false strategy appears at 5% significance. The history a desk does have is licensed. Nasdaq’s data policy says models trained on its information may be fee-liable. Cboe added a separate licensing category in July for its data used to train AI models whose outputs go to clients or third parties. US advisers must also enforce written policies against the misuse of material non-public information.

This piece is written for two engineers. The first is deployed inside an asset manager or a hedge fund and trains models this quarter on a mix of real and synthetic data. The second works at the frontier and wants to know whether synthetic data is an alternative to real data or the only option left. My answer, after three verified sweeps, is conditional and positive. Synthetic data substitutes for real data wherever a verifier exists. It complements real data where none does. A market has one history. No generator can add information that history does not hold. Between those poles the working rule is the one the August opener drew for a retail chain. The model proposes. Code decides. This special runs a systematic research house through that rule, because finance is the harder test. Its numbers must tie. Its clock must not leak. Its tails are the point.

What does one verifiable task look like?

Before the stages, one record. It comes from OpenFinGym, a gym for quant agents built by Edinburgh, UCL, the Alan Turing Institute and Oxford. Its September revision lists it for EMNLP 2026 Findings. It ships 78 curated tasks: 48 forecasting, 13 market generation, 10 trading and 7 fraud detection. It also ships a pipeline that turns published papers into new task packages, though the curated tasks were selected and verified by hand. The one below is 2_roughvol_generation. Its repository marks both dataset and metrics as verified against the source paper.

The scaffold owns almost everything. The source paper fixes the data-generating process, a rough-volatility model with Hurst parameter 0.25. The loader fixes a deterministic split of 16,000, 2,000 and 2,000 paths. The metric bank fixes eight scores and the rule that averages them. The model owns one thing, which is the code that fits a generator and writes 2,000 sample paths. Code checks the rest from outside. The verifier is a host process that loads the held-out paths into memory at startup and serves a submission API behind a bearer token and a rate limit. Held-out labels are excluded from the container’s mounts, which removes test-set leakage at runtime by construction. That separation is what makes the task usable as a reinforcement-learning reward: the policy sees its score and never the answer.

The post-training numbers show what such a reward buys and what it does not. Base Qwen3 models at 1.7B, 4B and 8B produced a scoreable submission on none of five held-out forecasting tasks. Supervised fine-tuning on 189 trajectories from Claude Opus 4.7 lifted per-task success to between 30% and 100%. GRPO on top reached 100% on every task at every size. The authors call it a demonstration of the SFT-then-RL loop. The base models failed mostly on hallucinated packages and wrong output shapes. The jump from 0% to 100% therefore measures executability more than modelling skill. Order-of-magnitude reward gains appear only on Treasury at every size and on Crypto at 1.7B. On the frontier-agent benchmark, market generation is the only family where any model scores below 100% success, at 70% to 90%.

One more detail matters for anyone copying the design. Market-generation totals are unnormalised. In one conditional-generation task in the same matrix, a cross-correlation score makes up about 98% of the total loss. A reward is only as informative as the rule that aggregates it, which is why an unweighted mean of metrics on different scales ends up tracking whichever metric is largest. For forecasts whose outcome is unknown at submission, OpenFinGym keeps a persistent ledger of each prediction with its reference state and resolution time. A resolver scores it once the future arrives. That is the only fully leak-proof label in finance. It costs a wait.

Can a generator roll the market’s dice?

A language model cannot. The Illusion of Stochasticity (COLM 2026) draws 1,024 independent calls per model per target distribution. Every model fails every goodness-of-fit test in its main table. A temperature sweep from 0 to 2.0 on Qwen3 models changes nothing. The August rule still holds for any number a pipeline needs: a PRNG draws it and the model describes it. Market generators are the finance version of that PRNG. They learn from price history and emit new paths. The hard question is what counts as a realistic path.

The oldest answer is Rama Cont’s 2001 list of stylized facts. Three of the 11 do most of the work in practice. Linear autocorrelation of returns is insignificant beyond about 20 minutes. The tail index sits between 2 and 5 for most series. The autocorrelation of absolute returns decays slowly, roughly as a power law with exponent between 0.2 and 0.4. A generator that misses the third fact misses volatility clustering, which is most of what a risk manager cares about. An Oxford survey of market generators adds the uncomfortable part. No accepted evaluation framework exists. Stylized facts and QQ plots are necessary checks that fall short of sufficient ones. The test has to match the use.

Four families of generator matter for a research house. The strongest results among them borrow a structure a practitioner could name.

A path’s fingerprint

Bühler, Horvath, Lyons, Perez Arribas and Wood built a generator for the setting every desk knows, a small sample. They cut about 20 years of S&P 500 history into roughly 250 monthly paths and summarised each path by its signature, the sequence of its iterated integrals.

S(X) = ( 1,  ∫ dX_t,  ∫∫_{s<t} dX_s ⊗ dX_t,  ... )
log S(X) = Σ_{n≥1} ((-1)^(n+1) / n) · (S(X) - 1)^{⊗n}
both truncated at a fixed order m

Truncated at a fixed order, the signature is a fixed-length vector. The full signature determines the path up to tree-like equivalence, which includes reparametrisation. Truncation loses little, because the terms shrink factorially with order. Continuous functions of the path are well approximated by linear functions of the signature. A variational autoencoder trained on log-signatures therefore learns from a vector short enough for 250 examples. Generated log-signatures are then mapped back to paths. On monthly paths the unconditional model passes a signature-kernel MMD two-sample test against real paths up to a confidence level of 99.987%. On weekly paths, a VAE trained on each week’s five daily returns fails the path-level test at 99.95% and two of five daily marginal tests, where the weekly signature model passes all six. The result I would carry into a small-data desk comes from the paper’s rough-volatility check: raising the training set from 250 to 5,000 simulated paths did not significantly improve the signature model. The fingerprint had already absorbed what the paths could teach.

Mixtures with a component count the data can carry

The humblest family did best in the one practitioner comparison I found. Risk.net reported in 2025 that a paper by Joerg Kienitz found Gaussian mixture models doing better than GANs and autoencoders at generating yield curves and volatility surfaces under the real-world measure. Kienitz told the magazine that GANs struggled with four years of daily data. Autoencoders gave some reasonable results. At one year both failed and the mixtures did not. He needed about seven components for overnight rates and three to five for equity volatility surfaces. The paper itself was not readable to me, which is why these numbers carry the magazine’s attribution.

p(x) = Σ_k π_k N(x; μ_k, Σ_k),    Σ_k π_k = 1
E-step: r_ik = π_k N(x_i; μ_k, Σ_k) / Σ_j π_j N(x_i; μ_j, Σ_j)
M-step: π_k = mean_i r_ik,   μ_k = Σ_i r_ik x_i / Σ_i r_ik
        Σ_k = the r-weighted covariance around μ_k

A mixture has two properties a risk manager likes. It has excess kurtosis without a tail model, because a rare high-variance component widens the tails. Far out, the tail still thins at a Gaussian rate set by the widest component. It also conditions in closed form: a Gaussian mixture conditioned on some of its coordinates is another Gaussian mixture, which turns an unconditional fit into a scenario generator given today’s state. What it does not have is a free component count. I wrote the smallest version I would put in front of a risk committee and ran it before printing it.

def fit_factor_gmm(dy, n_fac=3, k_max=8):   # dy: days x tenors, in bp
    mu = dy.mean(0)
    B = np.linalg.svd(dy - mu, full_matrices=False)[2][:n_fac].T
    f = (dy - mu) @ B                        # level, slope, curvature
    fits = [GaussianMixture(k, covariance_type="full", n_init=5,
             random_state=0).fit(f) for k in range(1, k_max + 1)]
    g = min(fits, key=lambda m: m.bic(f))    # K is chosen, never assumed
    return g, mu, B, (dy - mu - f @ B.T).std(0)   # residual: plain noise

def es_99(pnl): return -pnl[pnl <= np.quantile(pnl, 0.01)].mean()  # loss

def curve_es(dy, pv01, n=200_000, seed=1):  # pv01: P&L per +1bp, tenor
    g, mu, B, sd = fit_factor_gmm(dy)
    eps = np.random.default_rng(seed).normal(0, sd, (n, len(sd)))
    scen = mu + g.sample(n)[0] @ B.T + eps   # moves history never printed
    return g.n_components, es_99(scen @ pv01), es_99(dy @ pv01)

The test bed was a simulated curve whose true tail is known: eight tenors driven by level, slope and curvature factors with Student-t shocks and a two-state volatility regime, the stressed state at 2.5 times the calm one. The truth came from four million draws. Over 60 simulated histories per cell, I measured the mean absolute error of the 99% expected shortfall against that truth. With one year of data the mixture beat historical simulation clearly on a 2s10s flattener (18.2% error against 23.6%) and narrowly on a duration position (21.3% against 23.9%). It tied on a 2s5s10s butterfly at 12.4%. With four years of data history won the butterfly (7.7% against 10.9%), whose risk sits partly in the residual my factor model treats as plain noise. It edged the duration position (12.1% against 13.3%) by less than two standard errors. The flattener stayed with the mixture (10.5% against 13.0%).

The first version I wrote fitted the mixture on the eight tenors directly. With a year of data the Bayesian information criterion chose a single Gaussian in most runs, because each full-covariance component on eight tenors costs 45 parameters. The tail shrank with it. Error on the duration position rose to 34.7% against 23.1% for history on the same 40 histories. Three factors cut the cost of a component to 10 parameters. The criterion then picked two components in the median run. At one year a mixture earns its keep by borrowing structure from a factor model, while at four years history has enough tail of its own to catch up.

Diffusion on factors

Diffusion Factor Models take the same idea to hundreds of stocks. Returns follow a factor model. The score function a diffusion model must learn splits accordingly.

R = β F + ε                 d stocks, k factors, k << d
∇ log p_t(r) = s_factor(r, t) + s_linear(r, t)
s_factor: nonlinear, a network in the k-dim factor subspace
s_linear: linear on the complement, fitted with the loadings

Only the first term needs a nonlinear network. That network works in just k dimensions. The complement is linear, with coefficients set by the loadings and one noise variance per stock, all fitted alongside the network. The paper’s error bounds are driven mainly by k, which is the point of the construction: a 512-stock problem is learned at the cost of a handful of factors. On the 512 largest US stocks from 2001 to 2024, with quarterly re-estimation on five-year windows and 20 basis points of costs, a mean-variance portfolio built from generated returns reached a Sharpe ratio of 1.361 against 0.486 for equal weight. The sample and shrinkage portfolios on real data were negative in that table. They were negative only after costs, at between 0.427 and 0.617 without them. The hybrid rows locate the gain. Real means with generated covariance reach 1.090. Most of the improvement is therefore a better covariance estimate. Two limits belong next to those numbers. The model is cross-sectional and has no dynamics. In the paper’s own synthetic study of 2,048 stocks, the gains vanish once the training sample reaches 4,096 observations. The universe also dropped names with more than 5% missing data, which can flatter any method.

The investment manager’s traditional tools are the sample covariance, Ledoit-Wolf shrinkage and a factor model. At ICAIF 2024, Kubiak and colleagues tested a diffusion model on correlation matrices directly. The baselines were block bootstrap, a DCGAN, a WGAN and a VAE. In sample the unconditional diffusion model won clearly on futures, fixed income and stocks. On held-out test data most of the edge went. On futures it tied the bootstrap at a Wasserstein distance of 0.029 while the VAE led at 0.023. On fixed income it kept a narrow lead, 0.050 against 0.053 for the WGAN and 0.069 for the bootstrap. On stocks only the regime-conditioned model sampled at test-period volatility won, 0.055 against 0.082. The sobering row is the baseline: the historical training set’s own distance to the test set was 0.030, 0.053 and 0.078. Most generators were about as far from the future as the past was. A downstream test on one fixed-income strategy did favour the synthetic data: an XGBoost model trained on it forecast realised volatility with a mean absolute error of 57 basis points against 63 for one trained on history (Diebold-Mariano on squared errors, p = 0.1%). The gain came from the tail. At the median the synthetic model was slightly worse.

Scoring the tail directly

The risk manager asks whether a generator can reproduce the Value-at-Risk and Expected Shortfall of the strategies the desk actually runs. Tail-GAN trains a generator on exactly that (Cont, Cucuringu, Xu and Zhang, in Management Science this April). It uses the fact that VaR and ES are jointly elicitable: the true pair is the unique minimiser of an expected score.

S(v, e, x) = (W/2)(1{x≤v} - α)(x² - v²)
           + 1{x≤v} · e · (v - x) + α · e · (e/2 - v)
(VaR_α, ES_α) = argmin_(v,e) E[ S(v, e, X) ]

A discriminator reads a batch of strategy P&L and returns a (VaR, ES) pair. The generator is trained in a max-min game so that the pair computed from its scenarios scores on real P&L as well as the pair computed from real scenarios does. It does this for a library of buy-and-hold, mean-reversion and trend-following strategies at α = 5%.

Two readings follow. Both favour the traditional side. Historical simulation beats Tail-GAN on the synthetic benchmark and ties it on real intraday data. The authors print both results in their tables. Their text mentions only the second, saying historical simulation comes close. On 20 S&P 500 stocks Tail-GAN scores 25.6% against 25.9% for history. The generator’s value is new scenarios that preserve the risk numbers, which history cannot provide. The second reading is the one I would put in any model-validation document. The two bottom bars are the same architecture trained on fewer strategy types. They miss by more than 80%. A tail generator is validated only for the kinds of strategy it was trained against.

Generative Adversarial Regression, a March 2026 preprint from Ottawa, carries the same joint elicitability into a conditional generator. It swaps Tail-GAN’s quadratic score for an exponential one from the same family and adds an adversary that searches for the worst-case trading policy. On nine stocks from 1984 to 2025, a conditional generator trained on the joint score showed a VaR violation rate on strategy P&L of 6.6% against a 5% target, where DCC-GARCH showed 14.8%. The paper reports no coverage test and does not say whether its split is chronological. The adversarial result is the stronger one. A small generator trained against fixed strategies scored 1.233 on the worst-case strategy. With adversarial training it scored -3.761, lower being better.

A bank team ran the head-to-head that settles the baseline question for rates. Ericson and colleagues at Wells Fargo compared deep generators with the methods banks already use for interest-rate VaR on three USD yield-curve datasets. Average rank was 1.0 for plain historical simulation on a 251-day window, 2.0 for an AR(1)-GARCH(1,1) with Student-t innovations on returns and 3.0 for a conditional Wasserstein GAN. Composite scores were 1.473, 2.161 and 2.223, lower being better. History ranked first in all five seeds on the Libor curve and again on a cross-asset dataset of eight series. The GAN’s near-5% average breach rate hid a split of 1.6% in one sub-period and 7.7% in the other. The VaR backtest was not strictly out of sample.

The ceiling

Cetingoz and Lehalle, published in Quantitative Finance in July, supply the result that bounds all of the above. Their generator is a factor model with learned dynamics for 433 S&P 500 stocks.

X(t) = (β F(t) + Z(t)) ⊙ σ + μ
m = #{ λ_i > λ₊ },   λ₊ = (1 + √(d/n))²
F factors, Z residual, σ and μ per-stock scale and drift,
λ₊ the Marchenko-Pastur edge of the sample covariance

With their sample the edge sits at 1.90, which keeps 16 factors explaining 58.9% of variance. Three temporal convolutional GANs, one per cluster of factors, generate the factor series. Each stock’s residual is drawn independently from a fitted Student-t. Their Proposition 1 and its Corollary 2 are about that finite sample. Piling on synthetic samples cannot shrink the error below the bias the generator learned from it. Once that bias exceeds your tolerance, the chance of landing near the truth goes to zero as synthetic data grows. The practical sting is structural. An optimal portfolio scales its exposure to each principal component by one over that component’s variance. Portfolio construction therefore neutralises most of the high-variance exposure, above all in a market-neutral long-short book. What remains leans on the low-variance components, which a generator fitted to the high-variance ones learns worst.

Their Table 10 prices the history problem on generator-simulated data. With 12 years of daily data the standard error of such a Sharpe ratio is about 0.3. Getting it near 0.1 takes about 120 years. They then retrain the generator on its own output and ask it to recover Sharpe ratios known in advance, a screen they call the regurgitative test. Applied to their own generator, the test set a horizon limit. The authors conclude that it “should probably not be used for time scales that are longer than one month”. The test can reject a bad generator. It cannot certify a good one.

Factors also carried the curve mixture past history at one year. The tail score only tied history. Signatures beat a generator trained on raw returns and never faced history at all. The investment manager’s shrinkage estimator and the risk manager’s historical simulation stay the numbers to beat. The generator’s distinct contribution is scenarios history never printed, with the risk numbers intact.

Who writes the rules the gate enforces?

A research house runs on rules nobody would call interesting. Prices sit on a tick grid. A bar is the aggregate of its prints. A trade references an instrument that existed in the security master on that date. Weights sum to one. P&L ties to the ledger. No timestamp falls after the as-of date. Each is an exact check, which makes synthetic finance data tractable wherever those rules are the whole story.

Generators that learn a rule only as a training penalty break it often. J.P. Morgan AI Research measured it at NeurIPS 2023 on daily prices with an OHLC constraint. Their constrained-optimisation method met it in 100% of paths and their guided diffusion model in 72%. GAN baselines with the rule as a loss penalty did worse: TimeGAN 51%, GT-GAN 5% and RCGAN none. The architecture that avoids the problem puts the rule in code from the start. TradeFM, J.P. Morgan’s order-flow model, proposes the flow and hands it to a deterministic exchange simulator with price-time priority matching. The book mechanics are never the model’s job.

Validity is also where the easy wins stop. Chen and Glasserman trained an 86-million-parameter GPT-style model from scratch on order-book events from a simulator whose rules they knew. Across three training setups it generated valid event sequences between 95.5% and 99.4% of the time. It passed a test of whether it had learned the state of the book only 42% to 61% of the time, where a simple empirical-kernel baseline passed 99.9%. It also saw predictive patterns in past events that carry no information by construction, significant in 8 of 12 regressions. A generator can obey every rule of the book and still not know what the book looks like.

Rules the model proposes

Some rules live in nobody’s documentation. DIVE lets agents propose inter-column constraints from metadata and 100 sampled rows, as Python checks for equations and JSON for inequalities and logical dependencies. Each hypothesis is then validated against the full reference table at a violation rate of at most 0.005, with up to 20 counterexample rows returned for up to three revisions. One prompt reaches precision 0.73 and recall 0.63 on linear inequalities with Claude Sonnet 5. The loop reaches 0.975 and 0.919. On logical dependencies precision rises from 0.44 to 0.96. The accepted rules then run as a repair pass over generated tables. Equational violation rates of 98.2% and above fall to zero while mean column shapes per dataset move by less than 0.02. The model proposes in volume. The table says no. Once the table says yes, the rule is code.

For market data the check must be exact. Exact means integers.

def ticks(px, tick):                 # price -> integer ticks + on-grid flag
    t = np.asarray(px, float) / tick
    return np.rint(t).astype(np.int64), np.abs(t - np.rint(t)) < 1e-6

def check_bars(bars, trades, tick):  # trades: bar_id, px, qty, time order
    px, on_grid = ticks(trades.px, tick)
    g = trades.assign(px=px, off=~on_grid).groupby("bar_id")
    agg = pd.DataFrame({"o": g.px.first(), "h": g.px.max(),
                        "l": g.px.min(), "c": g.px.last(), "v": g.qty.sum(),
                        "off": g.off.any()}).reindex(bars.index)
    ok = agg.off.eq(False).to_numpy()    # no print between two ticks
    ok = ok & trades.bar_id.isin(bars.index).all()   # no orphan prints
    for k in "ohlc":                     # a bar is the sum of its prints
        v, grid = ticks(bars[k], tick)
        ok = ok & grid & (v == agg[k].to_numpy())
    return ok & (bars.v.to_numpy() == agg.v.to_numpy())

I ran it on 20,000 simulated bars of an index future on a 0.25 grid near 4,300, with 200 bars per fault type. It caught every off-grid high, every close above its high, every volume off by one contract, every open that disagreed with the first print and every off-grid print inside a bar. It passed every clean bar, including bars carrying float noise of a billionth of a point. The float comparison most code reaches for first is numpy’s isclose at its defaults. Its relative tolerance of 0.00001 allows 0.043 at a price of 4,300, more than four times the 0.01 error I planted in each off-grid high. It caught none of the off-grid highs and 24% of the off-grid prints. Running the block also exposed a defect before print. Under pandas 3 the first array comes back read-only. The in-place update in my first version raised an error before it checked a single bar. A second reader found a quieter gap: prints whose bar was missing from the bar table dropped out at the reindex. The orphan-print line closes it.

What the books check

Accounting is the cleanest verifier finance has. The evidence for model-written books is thinner than the confidence around them. FinBalance reconciles source-document bundles into cited journal entries and a balance sheet, with ground truth from a deterministic double-entry ledger. GPT-5 at low reasoning produces an exact balance sheet 46.5% of the time. The fix it demonstrates is the architecture of this piece: replay the model’s own entries through the ledger, diff section by section and hand the deltas back for one revision at temperature 0.

FinVerBench, a single-author preprint, renders 1,985 statement sets from the XBRL filings of 43 S&P 500 companies, 1,942 of them carrying one injected error. It compares a 15-rule identity checker with 14 model runs. The checker records no false positives on relationships that hold exactly in the clean data. It detects 1,026 of 1,942 injected errors. The paper traces the misses to line items the XBRL extraction omits and to checks that need accounting knowledge the statements never state. Nine of the 14 model runs flag between 95% and 100% of clean statements as wrong. Read the checker’s zero with its denominator. Only 43 instances are clean, which lets the paper’s own Wilson bound allow a true false-positive rate up to 8.2%. The transferable lesson: a model handed an incomplete checklist flags everything.

AuditCopilot gives the count-level version on 5,000 simulated postings with 50 injected anomalies. A union of journal-entry tests flagged 992 postings, 50 of them true. An isolation forest cut the false alarms to 169 at full recall. A prompted 8B model, told to flag an entry when two of five engineered flags fire, scored the same postings with 12 false alarms and 2 misses. The three ran side by side. The ordering below is my inference from the counts. Hard rules first, as a recall guarantee. Statistics second. A model third, as a false-positive filter.

The distinction between a warning and a refusal belongs at the top of any gate review. PersonaLedger, Capital One’s transaction generator, has a persona-conditioned model propose each day’s transactions inside a programmatic rule engine. The paper describes infeasible plans being rejected with targeted feedback. The shipped code retries an output only when it fails to parse into transactions, carries a malformed timestamp or mentions a deposit. Over-limit spending is accepted with a warning row, up to a third strike. A warning is a log entry. A refusal is a gate.

Reject, repair or project

Once a gate refuses, three options remain. One paper tries them on a finance table. Constrained Tabular Diffusion for Finance uses Lending Club data, where only about 10% of real rows satisfy its four portfolio rules jointly. A rejection gate on that rule set would discard nine rows of every 10. Projection forces each sample onto the feasible set. On Lending Club it takes violations from 90.22% to zero while distributional distance rises from 0.01651 to 0.11876. On New York housing, where about 57% of real rows already comply, distance moves only from 0.011 to 0.022. Both distances are taken against the real data as a whole. An exact sampler of the compliant slice would sit far from it too. Neither figure isolates what projection costs. The shape of the cost shows in one column. Under a floor of 1.5 reviews a month, the paper puts 70.2% of real listings below the floor. Projected rows show a mean of 1.9 with a standard deviation of 0.7. Mass piles onto the boundary of the rule. Soft penalties buy less than they appear to. Harpoon, at ICLR 2026, still leaves 20.55% of rows outside a range constraint on its hardest dataset.

Repair is the option the sweep prices best. DIVE’s repair pass zeroes equational violations while mean utility drops by at most 0.042. It regenerates nothing. A model writes one fix function per equation, validated once on the full reference table. Code then rebuilds the column in place. The rule I take from the three: reject while the acceptance rate is high. Once it falls, repair when one column can be rebuilt from the others and project when the rule bounds a region, as an inequality does. A quant will recognise the first trade as importance sampling, where the estimator stays unbiased while its variance climbs as the proposal drifts from the target. The analogy breaks in a useful place. No importance weight rescues a projected sampler, because the correct weight on the mass it piles at the boundary is zero.

The last gate result is a warning about gates. When Sample Selection Bias Precipitates Model Collapse, at ICML 2026, proves that a top-α selection gate whose reference is a biased slice of the target drives covariance to zero over generations. On two of its three image datasets, centroid-matching and covariance-matching gates scored a worse FID than random selection. A quant reads that as survivorship bias with a feedback loop. A gate calibrated on the survivors of one regime generates a market of survivors.

Which mechanism for which rule?

The rules are several kinds of thing. Each kind has a mechanism that fits it and a price somebody measured. Collected in one place, the missing mechanism is easy to see.

Syntax is solved by a full-automaton mask. Referential integrity is free when the security master is built first. Totals get an information projection, which hits them only in expectation. A book that must tie to the cent needs an integer adjustment afterwards. Trajectories need the entity as the unit of generation: PATH makes a user’s whole event sequence the unit and cuts distributional distance to real trajectories by 60.8% against a marginal-based mechanism, in a single run at its best privacy level. The amber row is the hole. Where vs What measures values that appear somewhere in the output at the wrong schema path. On its deepest schema that share runs from 24% on GPT-4o to 74% on Qwen2.5-7B, scored only on outputs that parse. A grammar can prove a record is well formed and has nothing to say about whether the value landed in the cell it belongs to.

What changes when the output is words?

Most of the synthetic data a research house will generate this year is text: questions over filings, labels on headlines, reasoning traces and extraction targets. Here the frontier has already answered the substitution question. NVIDIA reports that more than 98% of the data used to align Nemotron-4 340B was synthetic, with a reward model as the gate. Meta’s Llama 3 kept about a million generated code examples only after they passed a parser, a linter and unit tests in a sealed environment. DeepSeek-R1 rewards answers by rule and distils about 800,000 samples into smaller models, about 600,000 of them reasoning traces kept only when correct. The common element is a checker. The finance literature sorts neatly by how strong its checker is.

Checked by code

EY’s synthetic financial QA has GPT-4o write multi-step questions from the same financial-report excerpts experts used for FinQA, TATQA and ConvFinQA. Each answer is Python run in a separate interpreter. A pair is discarded when the code fails or returns the wrong type. Phi-3-mini trained on the synthetic set scores 68.43 on the real FinQA test against 73.49 on expert data. On TATQA the same model trails by about two points, 88.99 against 90.94. Tested across datasets, the synthetic-trained model does better, 84.26 against 81.19. The authors state the limit plainly: the gate checks that the code runs and returns the right kind of answer, which leaves the financial reasoning itself unchecked. FinLLMs moves the arithmetic fully into code by chaining 21 accounting formulas in a graph and letting a program compute every answer. A manual audit of 357 items found 97.48% correct, with the errors in units the model misread. The model still invents the input figures the formula consumes.

Checked by a model

Fin-R1 keeps 60,091 DeepSeek-R1 reasoning traces that a Qwen2.5-72B judge accepted, a judge the authors report at 99.6% accuracy over five repeated runs on 100 FinQA items. A 7B model trained on them reaches 75.2 on the authors’ five-benchmark average against 78.2 for DeepSeek-R1. An independent evaluation in Fino1 puts Fin-R1 below its own base model on long financial documents, 37.00 against 41.00 on one DocMath set and 13.67 against 17.67 on the other. Salesforce’s Llama-Fin uses GPT-4o to grade attempts at CFA practice questions. Removing that stage drops accuracy on the hardest CFA set from 55.56 to 35.56 on what appears to be about 90 items. The same stage cuts a financial-distress task from 96.41 to 40.81. A model judge scales. It also shares the blind spots of the model it judges.

Checked by people, on a sample

The buy-side case with the most honest numbers is a label pipeline. Capital Fund Management used Llama 3.1 70B to label company names in about 900,000 news headlines for roughly $70 of compute. Reviewers checked 2,714 of those labels by hand. A fine-tuned GLiNER model reached 93.4% F1 against 92.7% for the 70B model, at up to 80 times lower hourly cost. The gate paid for itself in one comparison. At 1,000 training samples, the small model scored 0.895 on unchecked labels and 0.915 on checked ones. J.P. Morgan AI Research reached the matching result on financial relation extraction: model labels were good enough to replace crowdworkers, fell short of domain experts and could be trusted on 65% of items. A Goldman Sachs team distilled filing retrieval the same way, with Llama-3.1-70B writing questions and grading passages for a small embedding model. MRR@5 improved by 27.7% across 14 filing types. The evaluation there was scored by GPT-4o.

Checked by a solver

InvestAlign (ACL 2025) is the contrast case, because no language model writes anything. Tsinghua’s authors want models that allocate the way real investors do when they partly follow an adviser, a setting where decision data is scarce. They take a Merton-style problem whose optimal solution is known. An investor with exponential utility pays a penalty for deviating from an adviser whose risk aversion is fixed at 0.2.

P₂(t) = v / (α₂ σ²) · e^{r(t - T)}        the adviser's holding
P₁(t) = P₂(t) · [α₂σ²η e^{2r(T-t)} + θ₁] / [α₁σ²η e^{2r(T-t)} + θ₁]

As the herding coefficient θ₁ goes to zero, the investor holds its own Merton weight. As it grows, the investor converges on the adviser. The solution is closed form up to one constant, η, found by fixed-point iteration. Code sweeps 10 risk aversions by 10 herding coefficients by 10 Brownian draws into 1,000 prompt-and-answer pairs. Models trained on the simplest problem were then tested on it and on two harder ones against questionnaire answers from 119, 80 and 44 finance students and professionals. Mean squared error to the class-average human answer fell by between 44.52% and 61.26%. On the harder relative-herding problem the theory-trained models also beat models tuned on FinGPT’s data. Mixing in real answers helped slightly at 10 parts theory to one part real and hurt at the reverse ratio. The task is a toy with small human samples. The principle is the cleanest in this section. Where a problem has a known optimum, the solver is the verifier. The label is correct before anyone reads it.

How much real data to keep

Two studies from opposite ends agree that a real share has to stay. The UK FCA’s synthetic data group trained challenger models on open-banking data at different blends (2024 report). Against a real-only model, accuracy fell 2.5% at half synthetic, 5.0% at 70% synthetic and 32.0% at fully synthetic. The group’s preliminary finding for this use case was that at least 30% real data was needed to keep accuracy strong. At the frontier, a Meta-led study of more than 1,000 models found pretraining on rephrased synthetic text alone no faster than on natural text, with about one-third synthetic the best mix. Over repeated rounds, the difference between replacing and accumulating decides the outcome. Under replacement, each generation trains on the last one’s output and error grows linearly with the number of rounds. Under accumulation, synthetic data is added on top of the real data and the error stays below about 1.64 times its first-round value however many rounds run. Shumailov and colleagues found that keeping 10% of the original data each generation left only minor degradation. Accumulate. Never discard the real anchor.

What the schema and the decoder do to the words

Two engine-level failures from the August sweep matter for any extraction pipeline over filings. The first is the schema. PhantomFill builds inputs whose ground truth is absence and asks 13 models the same unanswerable question under different output formats. Under a required closed-vocabulary field with no escape value, 10 of 13 models fabricate an answer every time. Every extraction schema needs an escape member and a model that will take it. GPT-5.5 took it every time. All nine open-weight models fabricated anyway, at 60% to 100%.

The second is the decoder.

Draft-Conditioned Constrained Decoding frames per-step masking as a sequence of projections that pay a tax wherever the model wanted a forbidden token. The Format Tax attributes most of the loss to the format instruction in the prompt. Both agree on the recipe: let the model reason freely, then format the result under the mask. The engine stays rented for format legality, with a validator behind it and no mask on the reasoning pass.

Can a model that has read the future write a point-in-time dataset?

This is the question finance adds to the synthetic-data literature. It cuts both ways. A model used to generate training data about the past may know how the past turned out. The Memorization Problem shows the scale for gpt-4o-2024-08-06, whose training cutoff is October 2023. Asked only for the S&P 500 close on a date, it missed by 0.61% on average with 80.6% directional accuracy over 8,488 days before the cutoff. After the cutoff the error was 16.9% and directional accuracy 45.7%, on 292 answered days. With the previous two closes in the prompt, post-cutoff error fell to 0.64%. Direction carries the signal: with the same two closes in the prompt, directional accuracy was 54.4% after the cutoff against 80.8% before. Instructions to ignore later information did not reliably stop recall. When they did lower accuracy, forgetting and hiding were indistinguishable.

AI’s predictable memory, in Economics Letters, trades on recall alone. GPT-4.1 asked for a stock’s return on a date with no context produced a daily long-short Sharpe ratio of 2.88. Removing 3.0% of the observations brought it below 0.2. Adding the same-day market return to the prompt raised the share that had to be removed to 21.4%. Glasserman and Lin found the opposite effect for GPT-3.5. Masking company names on Thomson Reuters headlines raised in-sample long-short returns from 10.74 to 13.84 basis points a day (p = 0.017). The net effect of knowing the name was negative, which the authors read as distraction outweighing any look-ahead gain.

The response the field converged on is point-in-time models. Bryan Kelly and colleagues at AQR, Yale and EPFL trained models up to 4B parameters on web text published before each monthly cutoff from 2013 to 2024. Long-short portfolios on their news embeddings reach annualised Sharpe ratios of roughly 1.0 to 1.5 on Dow Jones Newswire from 2014 to May 2020. Before instruction tuning, gpt-5-nano screened the public instruction data for time-sensitive facts. With length and language filters it cut six instruction sets from 742,055 examples to 660,421, by my count from Table 1. The paper reports no accuracy check of the screen. ChronoGPT-Instruct, from Washington University in St. Louis, builds yearly vintages from 1999 to 2024 and keeps about 425,000 instruction pairs that GPT-4.1 judged at maximum confidence to use only pre-2000 knowledge. On Dow Jones Newswire from 2007 to 2023, its leak-free model earns a news long-short Sharpe ratio of 0.95 before costs, against 1.53 and 1.76 for two larger chat models that had read the outcomes. The authors read that ratio, 54% to 62%, as a lower bound on the predictability that survives without leakage. Because the comparators differ in size and training, the ratio is a bound only.

DatedGPT, from CUHK and UCL, trains 12 models of 1.34B parameters from scratch on web documents filtered by crawl date. There is one model per cutoff year from 2013 to 2024. Its instruction data is where the thesis of this piece reappears. DeepSeek-V4-Pro turns dated documents into question-and-answer pairs under a lexical constraint: every word must come from the source document or from a fixed list of function words. A rule-based script drops any pair that breaks it. About 60,000 pairs survive per year. The finance test scores 61,290 firm-day headlines, each by the vintage whose cutoff precedes it. The lookahead-free portfolio earns an annualised Sharpe ratio of 3.20 before costs. On Sharpe it trails six of eight off-the-shelf models that had seen the outcomes. The paper’s comparability claim rests on its regression, 28.3 basis points per standard deviation of the signal against 29.5 for Llama-3.2-3B-Instruct. The paper also measures the leak directly.

r_{i,t+1} = α_i + δ_t + β₁ s^f_{i,t} + β₂ (s^b_{i,t} - s^f_{i,t}) + ε
t: trading day.  s^f: vintage y-1 scoring a headline from year y
s^b: the 2024 vintage, which saw everything

The coefficient on the difference is the lookahead premium, 26.4 basis points per standard deviation of that difference at a t-statistic of 10.65. Three prominent pipelines in 2025 and 2026 set out to build leak-free instruction data. Two of them let a model decide what counts as leak-free. One lets code decide.

The code version is small enough to print.

FUNCTION_WORDS = frozenset("""a an the of to in on at by for from with as
    and or but nor if than that this these those it its they their them he
    she his her we our you your which who whom whose what when where why how
    much many not no is are was were be been do does did""".split())
TOKEN = re.compile(r"\d+(?:[.,]\d+)*|[^\W\d_]+(?:'[^\W\d_]+)?")

def words(text): return TOKEN.findall(text.lower().replace("\u2019", "'"))

def pit_gate(pair, source):      # pair: generated question + answer
    allowed = set(words(source)) | FUNCTION_WORDS
    leaked = sorted({w for w in words(pair) if w not in allowed})
    return not leaked, leaked    # passes only if every word is traceable

The function-word list is mine, because the paper defines its list only as particles, conjunctions, pronouns and similar connectives. The tokenizer reads letters in any script, which catches a leak written in Chinese or with an accent. I ran the gate against an invented third-quarter 2019 filing for a fictional freight company. One pair written in the filing’s own words passed. Five other faithful pairs were refused on inflections alone. Pairs that mentioned a pandemic, the year 2020 or a revenue growth figure the filing never printed were refused, with the offending words listed. The inflection refusals are the less comfortable result. “How much did revenue rise?” fails because the filing says “rose” while an English question forces the base form. The paper gives no rule for inflections. Every lemma table a team adds is therefore a design decision the paper leaves open. The gate also passed “Revenue fell as fuel prices rose”, a false claim assembled entirely from words the filing contains. It passed “Revenue rose $4.2 million” as well, because the tokenizer drops currency and percent signs. A lexical rule bounds what a model can know and leaves open what it can claim, which is why the point-in-time gate and the fact gate have to be two different checks.

The other code-decided designs share one move: they compute the label and let the model write only the words around it. Yale’s Verifiable Forecast Actions derives each target action from the realised 10-day path in code and keeps only data available before the close of the prior day. OpenFinGym’s resolver waits for the outcome. Both put the clock in code.

The planted-leak experiment explains why that matters for backtests. Gençay gave a hand-written strategy tomorrow’s return as a feature. It posted a design-window Sharpe ratio of 34.7, an evaluation Sharpe of 51.5 and a Deflated Sharpe Ratio of 1.00. The author frames it as a deliberately extreme counterexample. The point survives the framing. The statistics that correct for search say nothing about the information set. Leak prevention has to live in the tools the agent is allowed to call, which is how his agent framework makes look-ahead features inexpressible. A review of 164 papers found that only 26.8% acknowledge look-ahead bias at all. This blog’s Look-Ahead-Bench note measured the same bias from the benchmark side.

The unit of synthesis follows: the dated document, the instrument’s path, the account’s sequence of orders. Generate the unit with its timestamp attached, then project the rows.

What does a backtest have to beat?

The hedge fund researcher’s traditional toolkit starts from one limitation: a walk-forward backtest tests a single path. Two corrections are now standard. The Probability of Backtest Overfitting cuts history into many pairs of halves and asks how often the in-sample winner falls below the median out of sample. A seasonal rule optimised over 8,800 parameter combinations on 1,000 days of random-walk prices showed a Sharpe ratio of 1.27, which a standard test calls real. The estimated PBO was about 55%. The Deflated Sharpe Ratio raises the bar with the number of trials and their spread. It also penalises negative skew and fat tails.

PSR(SR*) = Φ( (SR^ - SR*) √(T - 1) / σ_SR )
σ_SR = √( 1 - γ₃ SR^ + ((γ₄ - 1)/4) SR^² )
SR*₀ = √V · [ (1 - γ) Φ⁻¹(1 - 1/N) + γ Φ⁻¹(1 - 1/(N e)) ]
DSR = PSR(SR*₀)
SR^ the observed per-period Sharpe ratio over T observations,
γ₃ its skew, γ₄ its raw kurtosis (3 when normal), N trials in
the ledger, V the variance of their per-period Sharpe ratios,
γ ≈ 0.5772, the Euler-Mascheroni constant

The paper’s worked example is a Treasury strategy with a Sharpe ratio of 2.5 over five years of daily data. After deflation there is about a 90% chance its true Sharpe is positive. An investor with a 95% bar declines it. Had the researcher stopped at 46 trials, it would have cleared. The threshold depends on N and on the variance of the trials. Only a complete ledger of trials supplies both.

ADIA’s review of three backtest types sets out where synthetic data enters. The three are history once, resampled history and Monte Carlo from a model of the market. The third can generate as much data as a test needs, provided the model of the market is right, which is the hard part. The least controversial use of synthetic markets is the one that sidesteps that condition. Arian, Norouzi Mobarekeh and Seco built an artificial market whose truth they knew from Heston stochastic volatility, Merton jumps, drift bursts and regime switches. They used it to grade validation methods. Combinatorial purged cross-validation beat k-fold, purged k-fold and walk-forward on PBO and on the deflated Sharpe statistic, with walk-forward notably poor at preventing false discoveries. The authors also propose bagged and adaptive variants of it. I could read only the abstract. No number from it appears here. Synthetic markets are most trustworthy when they grade the tools, because there the generator’s job is only to be known. Every harness in this piece works that way.

Direct evidence for backtesting on generated paths is thinner. Koshiyama, Firoozye and Treleaven tuned and combined strategies on GAN-generated histories for 579 assets. With tree ensembles, median out-of-sample Sharpe was 0.098 against 0.074 for the stationary bootstrap. With neural-network ensembles the bootstrap led, 0.092 against 0.085. No Sharpe difference was significant under Wilcoxon tests. The LLM era added a search problem. In Gençay’s framework, GPT-4.1 composed 100 strategies through validated tools. The best one was deflated against a ledger of 102 trials. Its Sharpe ratio fell from 1.69 in the design window to 0.18 held out, a 4.7% return over four years against 40.8% for equal-weight buy-and-hold. It had already failed the deflated test at 0.86. The only arms the framework certified were passive buy-and-hold benchmarks.

The null that must lose

The evaluation contract needs one control more than any other: a model with no structure that the generator must beat. A UAI 2026 audit of tabular metrics built the tabular version, a product of per-column marginals that cannot represent any dependency. The audit ran it through the standard suite.

A logistic-regression discriminator on raw columns can only separate two tables through their means. Once the synthetic means converge, it has nothing left to look at. For return series the analogous null draws whole days with replacement. It keeps fat tails and the cross-section and destroys volatility clustering, which makes it exactly the thing a path generator has to beat.

def acf_abs(r, lags=20):          # r: days x assets, mean ACF of |r|
    a = np.abs(r) - np.abs(r).mean(0)
    return np.array([((a[k:] * a[:-k]).sum(0) / (a * a).sum(0)).mean()
                     for k in range(1, lags + 1)])

def iid_days(r, n, rng):          # the null: whole days, with replacement
    return r[rng.integers(0, len(r), n)]   # fat tails kept, clustering gone

def clustering_gate(real, synth, rng, k=20):   # the generator must beat it
    err = lambda x: np.abs(acf_abs(x) - acf_abs(real)).mean()
    base = np.array([err(iid_days(real, len(synth), rng))
                     for _ in range(k)])
    if err(synth) >= base.mean() - 2 * base.std(ddof=1):
        raise AssertionError(f"the null scores {base.mean():.3f}")
    return err(synth), base.mean()

I ran it on 10 years of simulated daily returns for five correlated assets from a GARCH process with Student-t shocks, whose absolute returns carry a lag-one autocorrelation of 0.177. A Gaussian mixture fitted to the daily return vectors, the same class of generator as the first code block, matched the in-sample marginals better than a fresh draw from the true process (a mean Kolmogorov-Smirnov statistic of 0.024 against 0.041). It matched the correlation matrix better too (mean error 0.013 against 0.017). Once I shuffled its draws, its absolute returns had a lag-one autocorrelation of -0.007. The gate refused it at 0.162 against the null’s 0.161. A block bootstrap with 20-day blocks passed on all 10 simulated histories. The true process passed on 9 of 10, which is the gate’s own price at this sample length. The mixture passed on 1. The shuffle matters. Scikit-learn returns mixture samples sorted by component. Left in that order, the mixture passed the gate on all 10 histories, because a run of draws from the high-variance component looks like a volatility cluster. The margin, two standard deviations of the null’s score, came to 0.005 on this history. It is a statistical floor. A production gate adds an economic one. A one-day scenario generator can beat the true process on in-sample static tests and still be the wrong tool for a path, because the thing it cannot see is the order of the days.

Memorisation, discriminators and simulators that can be gamed

A generator that looks too good may be replaying its training set. In the Journal of Risk and Insurance this year, Junike, Flaig and Werner define a memorisation ratio for scenario generators. Without memorisation the ratio converges to a known limit, 4/9 or about 0.44 in their yield-curve test. An autoencoder on German yield curves scored 0.51 in sample and 0.50 out of sample. Near-copies of the training curves scored 0.93. In a smaller S&P 500 test whose limit is 0.2, bootstrapped returns scored 0.64 in sample against 0.11 out of sample, the signature of copying history.

Market simulators add a failure that static data cannot have. Coletta, Jerome, Savani and Vyetrenko attacked a leading conditional order-book simulator at ICAIF 2023. A naive market maker posting fixed size at a fixed depth was consistently profitable in it. A second naive strategy made money by stacking bids to inflate level-one order-book imbalance, the input the simulator leaned on most. Randomising which book level fed that input improved volume and spread, though prices still trended about 10% from the open. Both naive strategies then lost money. Their advice is to run a strategy on several simulators and judge it on the spread of results, preferring one that makes profit too hard. For the frontier engineer building RL environments that advice generalises. A simulator that pays a naive strategy is a reward function with a bug in it.

Privacy closes the contract. J.P. Morgan’s survey of synthetic data in finance sets out six levels of protection, from masked identifiers up to simulations with no link to real records. The one production case I found with numbers sits low on that ladder. Atlas-X adds calibrated differential-privacy noise to the axe list J.P. Morgan sends to about 60 hedge-fund clients, at a privacy budget of 0.3. The paper reports two years in production. Its simulations on real inventory data put the cost at about a dollar per asset per day. On the audit side, Synth-MIA found that distance to the closest record correlates with actual leakage at only 0.225. It is the most common privacy metric in the tabular synthesis literature. The flight attendants’ union made the same argument against the Spirit sale in plainer words: records that keep their referential integrity may still be put back together.

The contract, in my reading of these results, has eight lines.

1. A null that must lose: whole days drawn independently for paths, a product of marginals for tables.
2. The stylized facts that matter for the use, with the autocorrelation of absolute returns always among them.
3. The desk’s own strategy library as the tail test, plus an adversarial strategy searching for the worst case.
4. PBO and the Deflated Sharpe Ratio computed against a complete ledger of trials.
5. A memorisation ratio and a membership attack on every release.
6. The regurgitative test and a stated horizon limit for any market generator.
7. Leak prevention in the tools, with the clock in code.
8. Tolerances locked before the first look.

Is synthetic data the only option?

The frontier case for yes is strong where a checker exists. AlphaGeometry trained on 100 million synthetic theorem-proof examples derived by a symbolic deduction engine, with no human demonstrations. It solved 25 of 30 olympiad geometry problems. Phi-4 made synthetic data 40% of about 10 trillion pretraining tokens.

The limits are just as well measured. Epoch notes that synthetic data has reliably improved capabilities only in narrow domains such as mathematics and code. Phi-4’s own ablations show synthetic-only models doing worse on knowledge and hallucinating more. The Meta-led study found pure synthetic pretraining no faster than natural text. Strong Model Collapse (ICLR 2025) finds that in its setting as little as one synthetic sample per 1,000 can cause collapse that more data does not fix. Yue and colleagues found that reinforcement learning with verifiable rewards mostly sharpens sampling toward reasoning paths the base model already had, since the base model wins at large pass@k.

My synthesis is the one this piece opened with. Synthetic data substitutes for real data wherever a verifier exists. It complements real data where none does. Finance has more verifiers than most domains: the interpreter for arithmetic, the ledger for accounts, the grammar for formats, the full-table check for rules, the solver for known optima, no-arbitrage tests for pricing and a dated source or a resolver for time. It has none for what the market does next, short of waiting.

The positive case follows from the right-hand column. In my reading the scarce asset moves from data to verifiers, which a research house already owns in greater number than a frontier lab does: the trial balance, the security master, the point-in-time database, the risk engine and the backtest ledger. The work is to wire them into the generator. Regulators’ own forums have started drawing the same line. The FCA’s Synthetic Data Expert Group, in a 2025 governance report that carries a disclaimer that it does not represent the FCA’s views, says synthetic data has no fixed quality score, only fitness for a use. It also warns that synthetic records leaking into validation sets inflate results. The US interagency model risk guidance issued in April excludes generative and agentic AI models from its scope, which leaves a conventional model trained on synthetic data inside it.

The adoption record argues for patience. The CFA Institute’s 2025 report judges generative synthetic-data methods not yet widely used in the industry, with Monte Carlo, the bootstrap and GARCH still the cornerstone. Generative AI itself is near universal, with 95% of 150 alternative investment fund managers using it according to AIMA. The distance between near-universal generative AI and unmeasured synthetic-data adoption is where the engineering work sits.

Von Neumann said it in 1949

The foundational source for this piece is a three-page summary, written up by George Forsythe, of a 1949 symposium talk that the National Bureau of Standards published in 1951. In Various techniques used in connection with random digits, John von Neumann wrote that “any one who considers arithmetical methods of producing random digits is, of course, in a state of sin.” A language model asked for a number is an arithmetical method. The same pages state the acceptance-rejection method in full. Draw two uniform numbers X and Y. “If Y>af(X), we reject the pair and call for a new pair.” Every gate in this piece is that paragraph with an executable rule in place of the density. His verdict on the arithmetic generators of his day was that it had been “more trouble to test them than to manufacture them”. Every Monte Carlo risk engine on a desk today inherits that ratio. The eight-line contract above is the same observation with more than 75 years of compute behind it.

What would I build first?

The August opener closed on eight decisions. For a research house the sheet grows to 12, each marked with the role it serves most.

1. Draw numbers outside the model (all). PRNGs, samplers and fitted generators produce numbers. The model describes them.
2. Keep history as the baseline (risk). Historical simulation and the block bootstrap led or tied in every head-to-head here. A generator earns a place by beating them on the desk’s own numbers.
3. Give the generator structure you can name (investment, risk). Factors above all. Choose the component count by criterion and check what it chose.
4. Train tail generators on the desk’s strategy library plus an adversary (risk). A tail generator is validated only for the kinds of strategy it saw.
5. Screen every market generator for regurgitation and state its horizon (investment, research). Retrain on its own output and recover known Sharpe ratios before trusting it.
6. Write rules into generation where you can and check them in integers everywhere (engineering). Ticks, cents and contract counts compare exactly.
7. Let the model propose rules in volume and accept them on the full table (engineering).
8. Order the gate: hard rules, then statistics, then a model as a false-positive filter (risk, engineering). A warning is a log entry. A refusal is a gate.
9. Put the clock in code (research, engineering). A lexical checker, a dated source or a resolver ledger. A model’s date screen is a proposal.
10. Log every trial (research). PBO and the Deflated Sharpe Ratio are only as honest as the ledger behind them.
11. Make a null lose (all). Whole days drawn independently for paths and marginals for tables. Shuffle generated draws before any test of order. Calibrate the gate on a fresh draw from a known process.
12. Accumulate synthetic data on top of real data (engineering, frontier). Keep the share of real data your own ablation says you need.

How this piece was built

Three verified sweeps feed it: 107 engine papers from the last 12 months, 76 finance sources checked at their primary source (73 kept, older baselines included on purpose and dated in the text) and 43 finance training directions. A data-economics round checked 88 facts and corrected 17. Two adversarial rounds then reopened the sources behind the draft itself, the second with one verifier and one refuter per section. They caught readings that would otherwise have printed. Cetingoz and Lehalle prove a bias bound, which is narrower than “a generator adds no information”. The baseline that read as a raw-return GAN turned out to be Tail-GAN trained on single-asset buy-and-hold. A diffusion paper’s 4,096 was a sample size that I had read as a stock count. My own claim that every generator beating history borrowed a nameable structure did not survive the refuter. The Spirit hearing reported for 16 September had moved to 30 September. All four code blocks ran before printing. Running them exposed a pandas 3 read-only array, a mixture that collapsed to one Gaussian on raw tenors and a lexical gate that refuses ordinary questions over one inflection. A second reader then reran them and found a position I had labelled a steepener that was signed as a flattener, a shuffle I had not disclosed and an orphan-print gap.

Where it still breaks

Several things this piece could not settle. I found no public case of a named buy-side firm running synthetic market data in production. No survey measures adoption. The Spirit sale remains open. Two sources were readable only in part: the Arian study as an abstract and the Kienitz paper through Risk.net, which is why neither contributes a number of its own. The GAR preprint does not say whether its split is chronological and reports no coverage test. The look-ahead screens in two of the three point-in-time pipelines have no reported accuracy check. The lexical rule of the third does not stop a false claim built from true words. OpenFinGym’s jump from 0% to 100% measures executability more than modelling skill.

Three more are mine. The harnesses behind my code blocks run on simulated markets whose structure I chose. They show mechanisms. Magnitudes need real data. The mechanism table’s middle column holds my defaults. Its security-master row carries no measurement, because nobody measures what cannot fail. The quad is a placement. The line between “complement” and “substitute” will move as verifiers for market behaviour appear. The Cetingoz ceiling is a proven result. Everything around it is engineering.

The bottom line

Real data has a price. The Spirit auction put a number on it. For a research house the scarcer resource was always history, which no generator adds to. What synthetic data adds is method. Wherever an exact verifier exists, generated data can already stand in for much of the real data. Where none exists, the evidence says complement and test hard. The oldest methods on the desk remain the numbers a market generator must beat. The clearest wins over them came from borrowing a structure a practitioner could name, above all factors. The model proposes. Code decides. The accepted proposal becomes code.

Real data has a price. Synthetic data has a method. In finance the method is a verifier: a ledger, a tick grid, a solver, a dated source, a null that must lose. A research house already owns more of those than any frontier lab. The work is to wire them into the generator, keep history as the baseline and let the model propose while code decides.

References

The 15 sources this piece leans on most, in APA style. Every other source is linked where it is cited.

• Bailey, D. H., & López de Prado, M. (2014). The deflated Sharpe ratio: Correcting for selection bias, backtest overfitting, and non-normality. The Journal of Portfolio Management, 40(5), 94-107. https://doi.org/10.3905/jpm.2014.40.5.094
• Bühler, H., Horvath, B., Lyons, T., Perez Arribas, I., & Wood, B. (2020). A data-driven market simulator for small data environments (arXiv:2006.14498). arXiv. https://arxiv.org/abs/2006.14498
• Cetingoz, A. R., & Lehalle, C.-A. (2026). Synthetic data for portfolios: A throw of the dice will never abolish chance. Quantitative Finance, 26(8), 1311-1342. https://doi.org/10.1080/14697688.2026.2673155
• Chen, M., Xu, R., Xu, Y., & Zhang, R. (2025). Diffusion factor models: Generating high-dimensional returns with factor structure (arXiv:2504.06566). arXiv. https://arxiv.org/abs/2504.06566
• Cont, R. (2001). Empirical properties of asset returns: Stylized facts and statistical issues. Quantitative Finance, 1(2), 223-236. https://doi.org/10.1080/713665670
• Cont, R., Cucuringu, M., Xu, R., & Zhang, C. (2026). Tail-GAN: Learning to simulate tail risk scenarios. Management Science, 72(4), 2917-2936. https://doi.org/10.1287/mnsc.2023.00936
• Ericson, L., Zhu, X., Han, X., Fu, R., Li, S., Guo, S., & Hu, P. (2024). Deep generative modeling for financial time series with application in VaR: A comparative review (arXiv:2401.10370). arXiv. https://arxiv.org/abs/2401.10370
• Gençay, E. (2026). What survives honest evaluation? Leakage-safe, search-aware assessment of LLM-driven trading strategy discovery (arXiv:2608.27734). arXiv. https://arxiv.org/abs/2608.27734
• He, S., Lv, L., Manela, A., & Wu, J. (2025). Instruction tuning chronologically consistent language models (arXiv:2510.11677). arXiv. https://arxiv.org/abs/2510.11677
• Lopez-Lira, A., Tang, Y., & Zhu, M. (2025). The memorization problem: Can we trust LLMs’ economic forecasts? (arXiv:2504.14765). arXiv. https://arxiv.org/abs/2504.14765
• von Neumann, J. (1951). Various techniques used in connection with random digits. In A. S. Householder, G. E. Forsythe, & H. H. Germond (Eds.), Monte Carlo method (National Bureau of Standards Applied Mathematics Series, Vol. 12, pp. 36-38). U.S. Government Printing Office. Scan of the Collected Works reprint.
• Wang, H., Pan, Z., Zhang, H., Liu, M., Gao, H., & Zhao, H. V. (2025). InvestAlign: Overcoming data scarcity in aligning large language models with investor decision-making processes under herd behavior. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) (pp. 10021-10052). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.acl-long.495
• Yan, Y., Tang, R., Gao, Z., Jiang, W., & Lu, Y. (2026). DatedGPT: Preventing lookahead bias in large language models with time-aware pretraining (arXiv:2603.11838). arXiv. https://arxiv.org/abs/2603.11838
• Zhang, K., Ge, W., Jiang, L., Yang, W., Langham-Lopez, J., Yu, J., Szpruch, L., & Ni, H. (2026). OpenFinGym: A verifiable multi-task gym environment for evaluating quant agents (arXiv:2606.26350). arXiv. To appear in Findings of EMNLP 2026. https://arxiv.org/abs/2606.26350
• Zhao, J., Guan, M., & Liu, D. (2026). Constraint-aware synthetic tabular data generation via inter-column constraint discovery with LLM agents (arXiv:2608.15109). arXiv. https://arxiv.org/abs/2608.15109