What we are researching

How to read this site

Everything under /ai-ml/training/ is a live view of experiments running on supercomputers, where a job takes whole nodes of one of two kinds. The A100 nodes each carry 128 CPU cores, four NVIDIA A100 graphics processors with 40 GB apiece, and half a terabyte of memory. The H100 nodes each carry 256 CPU cores, 4 NVIDIA H100 graphics processors, 600 GB memory. The index lists each study with one line of status. Each study has its own page with the detail: which runs are finished, which are on the machines now, what the numbers look like so far, what it has cost. The jobs section on the index lists every job we have on the supercomputers in plain words: what it belongs to, whether it is waiting, running or finished, how long it has run, and how many nodes it uses and what is in them.

The pages are refreshed every few minutes while one of us is logged in. When nobody is, a page keeps its last figures and says since when. Every number is copied by a script from the scheduler's records or the training program's logs.

Study 1: how a language model should read a word

A language model is a program that predicts the next piece of text from the pieces before it. Inside, text is cut into small units called tokens (a word, part of a word, a digit, a symbol). The very first thing the model does with a token is look it up in a table and read out a list of a few hundred numbers. That list is the token's starting representation; every later step of the model works on lists like it. The table is learned along with everything else, but it is still a table: the token bank gets the same list of numbers whether the sentence is about a river or about money, and the token for walked shares nothing, by construction, with the token for walk. The deeper layers of the model repair this later, and they do it well enough that the field has mostly left the table alone.

Our question is whether the table is the right starting point at all. The alternative we are testing: instead of each token owning its own private list of numbers, every token's starting list is built, on the spot, as a mix of a few entries drawn from one shared set of building blocks. Think of a paint shop that keeps a few hundred pigments and mixes every color you ask for from a handful of them, rather than a warehouse that keeps a sealed tin of every color ever ordered. The mix can depend on the words that came before (so bank after river can be mixed differently from bank after investment), and the model may take a second and third look at the mix before it commits, each look using the same small adjustment rule.

The hypothesis: forcing every token to be assembled from a small shared kit of parts should make the model better at handling combinations it has never seen, because the parts have had to earn their keep across many different tokens. A model with a private tin for every token has no such pressure. If this is right, the built-from-parts model should do better exactly on the test cases that recombine familiar pieces in unfamiliar ways, and no better on the cases it has effectively memorized.

Why it matters

The ability to recombine familiar pieces into new wholes is called compositional generalization, and it is one of the things current models do least reliably. A person who knows what jump means and what twice means can act on jump twice the first time they hear it. Models trained on text often cannot, unless they have seen that exact combination. A change that improves this, even at small scale, would matter. Changes of this kind also have a long history of looking good in a demonstration and vanishing under a fair test, so a clear negative result would be informative too.

Each idea in the proposal gets a twin that costs the same but lacks the one ingredient under test. If the twin does as well, the ingredient did nothing.

How it works, nuts and bolts

The part that never changes

Every model in the study has the same body: a small transformer, the standard architecture behind today's language models, with six layers and about eleven million adjustable numbers. It reads a sequence of tokens and predicts the next one. We train it from a blank start, many times, on exactly the same data with the same settings. The only thing that differs between the versions is the front end, the piece that turns a token into its first list of numbers.

The front ends being compared

A. Table

The ordinary lookup: one private list of numbers per token. This is the baseline.

B. Shared parts, no context

Each token is a fixed mix of a few entries from a shared kit of 128 parts. The mix is the same wherever the token appears. This separates sharing parts from reading context.

C. Dense context (control)

A small reader looks at the words so far and writes a fresh list of numbers for the token, with no kit and no sparsity. It costs the same as D and lacks only the constraint.

D. Sparse context

The same small reader, but it may only choose a few parts (four, by default) from the shared kit and mix them. This is the idea under test.

E. Dense, refined (control)

C, plus a second and third look: a shared adjustment rule applied twice to the fresh list.

F. Sparse, refined

D, plus the same second and third look, applied to the choice of parts and their weights.

D with a frozen kit

As D, but the kit of parts is random and never learns. If this does as well as D, the gain does not come from learning the parts.

Q. Quantized

Each token keeps its private list but also gets snapped to the nearest of 128 shared class entries. A simplified stand-in for a published method that improved these same tests; it is here so our results can be placed next to that work.

The tests

The question is about recombination, so each test has a known right answer and a known structure, which lets us hold specific combinations out of the training data.

Tiny programs. We invented a small world: a point on a seven-by-seven grid and seven operations that move it (shift right, shift up, scale, rotate a quarter turn, flip, swap coordinates). A program is a start point and a short list of operations; the model must write out where the point ends up after each step. It is arithmetic a child can check, and code checks every answer. Then we hold things out:

• Unseen pairs. Eight of the 49 possible this operation then that one pairs never occur in training. The test is programs that contain them. The model has seen every operation, but never those two back to back in that order.
• Unseen roles. Six specific operation-and-argument pairings (such as shift right by 3) never occur in training, though shift right with other amounts and 3 with other operations both do.
• Longer than ever seen. Train on programs of up to four steps; test on five to eight. This one is a known wall for models of this kind and we expect every version to fail it; it is here so that a surprise would be noticed.
• New names. An invented word is defined by three worked examples at the start of the input (here is what fa does) and then used inside a program. In training, each invented word was defined as various operations; in the test it is defined as an operation it never stood for before. This is the test closest to the hypothesis: the model has to build a meaning for a word from context, on the spot.

An established benchmark. SCAN is a public test from 2018 in which commands like jump around right twice must be translated into action sequences. Its famous split teaches the model jump only on its own and then asks for jump inside every construction it has learned with other verbs. We use that split and the length split.

Less data. With a hundred thousand training programs the plain model already solves the new-names test almost perfectly, which leaves nothing to measure. So those two tests are also run with a fifth of the data, where the plain model drops to about a third right on the held-out cases and there is room for a difference to show.

What makes it fair

• Every version has the same body, data, training length, batch size and learning schedule, and runs with three different random starts, so that we can tell a real difference from luck.
• The front ends are close in size and in arithmetic per token; the exact counts are recorded with every run. Where they differ (the refined versions cost a little more), a twin that costs the same but lacks the tested ingredient is in the grid.
• The front end is forbidden from peeking ahead. A test built into the code checks that changing later words never changes the representation of earlier ones; it runs on the training node before any training starts.
• All scores are on the whole held-out set, and we quote only the score at the end of training, never the best moment along the way, because choosing that moment on the test set itself would inflate the score.
• Reviews of the code after the first submission found that one version started with a setting that made it blind, and that two others did not start from the position the method describes. Those 78 runs were redone under corrected code.

The design, in one table

The full plan is in the study's repository; the short form is below.

What counts as an answer

These were written down before the first job was submitted.

1. Sparse beats dense. Version D (sparse context) beats its same-cost twin C on at least two of the recombination tests, by more than twice the spread between random starts, while doing no worse on the ordinary, non-held-out test. This is the main claim.
2. Learning the parts matters. Wherever 1 holds, D also beats the frozen-kit version.
3. The second look helps more when the kit is there. Going from one look to four helps F more than it helps E.
4. Sanity. On tests with nothing held out, no version should differ from the plain table by more than the spread between random starts. A version that does points to a fault in the experiment.

If C does as well as D, reading context helped and sparsity did not. If the frozen kit does as well as the learned one, the kit need not be learned. If the extra looks help E and F equally, the gain comes from taking a second look, and the kit adds nothing to it.

The study closed on 5 October 2026 as a negative result: in 447 runs no front end beat the plain table. In the first 270, the one lead was unseen roles, where the sparse version scored 0.565 against 0.200 for the dense one over three starts. A confirmation grid of 177 runs on the H100 nodes reran that test with five new starts, and the sparse version scored 0.372 against 0.380 for the dense one and 0.575 for the table. Identical runs of this test land high or low depending on the start, so three starts had given a misleading gap.

At a larger model size, on two other choices of held-out pairs, the sparse version scored above the dense one (0.451 against 0.233, and 0.486 against 0.253), but by less than the margin on both, and it did not beat the table either (0.382 and 0.247). On COGS, a public test of new combinations in English sentences, the sparse version scored 0.177 against 0.221 for the dense one. The new-names test at 5,000 episodes could not be read, because the plain table reached only 0.54 on familiar cases.

Where to look

• The guide: the study from the ground up, with the tasks, the model, the training schedule, the pass lines and interactive figures.
• The live page: finished and running counts, the chain of jobs, the results table (tests as rows, versions as columns, held-out and ordinary scores), which parts of the kit the sparse versions actually use, cost and disk, and anything that needs attention.
• The same thing as plain text, one screen, refreshed with the page.
• The jobs list on the index: every job on the supercomputers in plain words.
• The code, the data generators, the tests and the written plan live in a repository that is private until the write-up is out; the plan, the review reports and the results will be published with it.

Study 2: the fold the network chooses

In each layer of a language model, a step called the MLP (multilayer perceptron) stretches a token's 384 numbers to a longer list, bends each number with a fixed curve, and squeezes the result back. We call the curve the fold (in the field, the activation function) and each position in the longer list a channel. Published models use one fold everywhere; here each channel learns its own.

Why it matters

Without the fold, the stretch and squeeze would collapse into one matrix. The fold also decides which tokens teach which channels: in training, the correction a channel takes from a token is scaled by the fold's slope at that token's value. A sharpness learned per channel has been tried in image models only.

Published gains from new folds are 0.007 to 0.041 nats (the unit of prediction error; lower is better); runs differing only in their random start scatter by 0.003 to 0.010. We give even odds that the learned folds show a readable pattern by depth, and one in five that a learned or restructured fold beats the gated unit below.

How it works, nuts and bolts

Folds and gates

The model starts from SiLU, which multiplies its input by a smooth gate rising from 0 to 1: large positive inputs pass almost unchanged, large negative ones come out near zero, and the curve dips to −0.278 at −1.278. The learned fold gives each channel three numbers, the gate's sharpness and settings for the dip's depth and width, starting at SiLU's values (bounds: sharpness 1/16 to 16, depth and width 1/4 to 4). A very sharp gate makes a hinge, flat below zero.

SwiGLU, the gated unit in most current models, reads the token twice in each channel, folds one reading and multiplies the two. Three matrices at 1,024 channels hold as many weights as the plain MLP's two at 1,536.

The versions

S. SiLU

The plain fold.

SG. SwiGLU

The gated unit.

R2. Squared hinge

A published rival to SwiGLU.

L. Learned fold

As described above.

Lx. Other start

L started at sharpness 2, depth setting 0.5. A pattern L and Lx share is a preference; one that follows the start is drift.

L0. Held

L held at SiLU's values.

SS. Sign split

Each channel's negative side gets output weights of its own.

D2. Second fold

Stretch and fold twice: 384 to 768 to 768 to 384.

Matched cost

Every version holds 1,179,648 MLP weights per layer, each used once per token, so all do the same multiply-adds per token. Offsets and the learned fold's 4,608 numbers per layer add under 0.3 %.

The design, in one table

What counts as an answer

Scores are held-out loss per source, averaged over three starts. Beats means lower by more than the margin, twice the pooled spread between starts; matches means a difference no larger.

1. F1, shapes by depth. In L, the median sharpness, or the median low point of the dip, in the last four layers differs from the first four by more than the margin, and Lx agrees in direction.
2. F2, a fold as good as a gate. L, SS or D2 matches or beats SwiGLU on every source, with a margin below 0.02 nats.
3. F3, the stronger form. One of them beats SwiGLU on at least one source and matches or beats it on the other two.
4. Positive control. SwiGLU beats S on web text. If not, the setup cannot see a gap of the published size (0.043 nats at 220 million numbers), and F2 and F3 stay unresolved.

L0, which tests the new code, must match S, or nothing else is read. A result that flips at another learning rate is reported as rate-dependent. Fold numbers move most where the training signal is strongest, which varies with depth, so each layer's movement is shown beside its signal.

If F1 fails, free channels show no depth pattern beyond the scatter, or one that follows the start. If F2 fails while the control passes, neither shape nor layout buys the gate's advantage at about 30 million numbers, as expected if gates help by easing training. If the control fails, the model is too small for the question.

The study closed on 5 October 2026 after 50 runs and 14.5 node-hours. The positive control held: SwiGLU beat S by 0.069 nats on web text. The learned fold was worse than SwiGLU by 0.018, 0.021 and 0.019 nats on web text, mathematics and code, and the sign split and the second fold were worse by more (0.10 to 0.13 and 0.056 to 0.063), so F2 and F3 fail. L0 matched S within 0.0001 nats, and no ordering changed with the learning rate. In the last four layers the learned gates came out softer and the dips deeper than in the first four, in the same direction from all three starting shapes, but how far the shapes moved followed where they started, so the depth pattern is recorded as drift. Among the fixed folds, R2, the squared hinge, came out ahead of SwiGLU on every source, by 0.011 nats on web text.

Where to look

• The New lines section of the study page.
• The lab notebook, which asks for a member passkey.

Study 3: context inside the map

Study 1 put context into each token's starting numbers and found no gain. In 536 failures on its unseen-roles test, read by hand, the first mistake always fell at a held-out pairing of operation and amount, and all 1,473 familiar ones were right. They look like recall of the nearest stored pair: of 164 failed shifts, 114 used the right operation with the nearest amount seen. A standard MLP applies the same weights in every sentence; here context acts on those weights.

Why it matters

Binding a role to a filler, this amount to that operation, is easy for people and hard for small models. If the cause is an MLP blind to context, one that reads context should bind better.

No paper we found compares ways for context to set a layer's weights on one task beside versions built to show no effect. We give one in three for a binding gain beyond the scatter between starts.

How it works, nuts and bolts

Three ways in

Context is the attention output: what attention, each layer's other step, gathers from earlier tokens. Only the MLPs of study 1's plain model change.

P. Plain

Stretch to 1,536 channels, fold, squeeze.

G. Gated unit

As in study 2, with GELU; the gate reads the token.

C. Context gate

The gate reads the attention output.

W. Weight change

A small network reads the running average of attention outputs and sets 16 numbers that change the stretch matrix along 16 learned directions, starting at zero.

G0, C0, W0. Frozen

Gate held at its random start; W's change held at zero.

C-shuf, W-shuf. Shuffled

Reading another sequence's context.

A real gain should vanish when frozen or shuffled; G controls for C reading the token itself. G and C keep P's 1,179,648 MLP weights per layer, and W pays for its 56,016 extra numbers by narrowing to 1,464 channels, so all cost about the same.

Swapped twins

Study 1's programs move a point on a seven-by-seven grid, wrapping at 7. Role binding, the unseen-roles test, holds out six pairings: shift right by 1 or 3, shift up by 2 or 4, scale by 5 or 6. In the first design many held-out steps had a training twin with coordinate and amount swapped: scaling 3 by 5 equals scaling 5 by 3. A product of two digit readings, which a gated unit forms, can pass such steps by that symmetry without binding the new amount to its role.

The swap-free design holds out both orders, so no held-out step has a twin. Shift-only programs and those with a scaling are scored separately: all of the first and none of the second already scores about 0.585, near the plain model's 0.578.

The design, in one table

What counts as an answer

Scores are exact match, averaged over three starts. Beats means higher by more than twice the pooled spread between starts. X1 and X2 also need the familiar-program score within 2 points (0.02) of P.

1. X1, binding. G, C or W beats P on swap-free role binding, in the shift or the scaling part, and neither its frozen nor its shuffled version does.
2. X2, recombination. The same on unseen pairs, where the score to beat is 0.677.
3. X3, credit to context. Only if C also beats G and C-shuf, or W beats W-shuf.
4. X4, the twin route. On the first design, a scaling gain larger where both twins were seen, and absent in the swap-free design, is reported as a gain through the twins.
5. X5, new names. G, C and W against P at 5,000 episodes, or 2,000 if P reaches 0.95 there; untested if P scores below 0.90 on familiar episodes.

P rerun on the new code must reproduce study 1's 0.577 ± 0.050 on unseen pairs and 0.578 ± 0.051 on role binding, or nothing is read. W0 must match P, and ten failures per task are read by hand first.

If nothing passes X1 or X2, these three routes leave binding and recombination unchanged at this size. If G passes and C does not beat it, the gain belongs to the product form. If W tracks W0 with nearly constant numbers, the change went unused.

The first 135 runs met no line. No version beat P on swap-free role binding or on unseen pairs (X1 and X2), so nothing was credited to context (X3). On the first design every scaling success came on a program whose swapped twin was in training (X4), and new names could not be tested because P scored 0.70 on familiar episodes. Two shuffled versions scored above P, and a check of 81 runs with nine starts per version read both. W-shuf's lead on unseen pairs was seed luck: over nine starts it scored 0.648 against P's 0.601, a gap the paired test does not separate from chance. On the swap-free scaling programs, models whose MLPs do nothing scored more than P: 0.115 with the MLPs switched off and 0.134 for C-shuf, whose gate shut itself, against 0.071. That small effect stays provisional.

Where to look

• The New lines section of the study page.
• The lab notebook, which asks for a member passkey.

Study 4: the referee and the cleaner

Two programs that read scientific papers. The checker redoes a paper's calculations from the paper's own data with four small tools and reports, claim by claim, what holds, what does not, and what it cannot check. The cleaner rewrites text drafted with a language model the way a person would write it, without changing a number, a citation or an equation. Both start from openly published models of about 32 billion parameters and are trained further on nodes with four A100 cards, with rewards a program can verify rather than a judge's opinion. The guide at /ai-ml/training/llm-dev/guide/ builds the design up from the ground; the status page shows each stage and its replay.

Study 5: the multiplication primitive

In study 3 no way of feeding context into the MLP helped a model bind an amount to an operation. This study changes what the MLP can compute: a plain channel folds one number, so a squared fold gives the square of a feature but no product of two.

Why it matters

A token runs down one street of blocks, and each block's MLP reads it once, along the axes its matrices were trained in. Studies 5 and 6 read the same learned matrices several times in parallel, each through a turned frame, and average them, which adds views without adding weights.

The simplest frame turns each pair of channels by 45 degrees. Squaring the turned pair, (a − b)/√2 and (a + b)/√2, gives two squares whose difference is 2ab, a product of two channels. A product binds two features: scale times 5 is large only when both are present. On the swap-free scaling programs study 3's plain model scored 0.071, near the 0.027 that any amount gets right.

How it works, nuts and bolts

The first stream folds the stretched channels as they are. The second turns each pair (a, b) by 45 degrees, folds it and turns it back; with the squared fold the pair returns as (a² + b²)/√2 and √2·ab (Figure 3). The squeeze matrix reads the mean of the two streams. Both streams share one stretch and one squeeze matrix, the plain MLP's 1,179,648 weights per layer, at twice its multiply-adds.

P. Plain

Study 3's plain MLP.

PR2. Turned pair

The two streams, with the squared fold.

PR2-silu

PR2 with SiLU, to separate the turn from the square.

AX2. No turn

Two unturned squared streams: a plain squared MLP.

P-wide. Wide

3,072 channels, PR2's extra arithmetic spent on weights.

A product is symmetric, so on study 3's first design, which has swapped twins, each version's gain on twin steps is printed beside its gain on other steps.

The design, in one table

What counts as an answer

Comparisons are paired by start at the 5 percent level. Beats also needs a gain of 0.05; no worse by b rules out a shortfall of b.

1. M1, binding through products. PR2 beats P and AX2 on the scaling part of swap-free role binding.
2. M2, no cost elsewhere. PR2 is no worse than P by 0.05 on unseen pairs and the shift part.
3. M3, text at equal compute. PR2's loss is no worse than P-wide's by 0.02 nats on each text source; PR2-silu is read beside it.

P on the new code must match study 3's P on unseen pairs within 0.05, or nothing is read. MLPs left idle by the square would score near the 0.115 of a model without MLPs; AX2, with the same square, rules that out. Ten failures per version are read by hand.

If PR2 beats P but only matches AX2, the square carries the gain. If it matches both, channel-wise products do not bind a held-out multiplier at this size, as the gated unit's did not (0.03 to 0.05).

Where to look

• The New lines section of the study page.
• The lab notebook, which asks for a member passkey.

Study 6: one matrix read from several angles

Study 5 reads the MLP's weights through one fixed turn. Here they are read in four streams, each through its own random rotation, drawn once and then held fixed, and the layer passes on the mean of the four. A second test reads the trained weights through rotations they never saw.

Why it matters

A matrix holds information twice: as the map along its own axes, which input direction feeds which channel, and as the relationships inside it, such as the angles between its rows, which a rotation leaves unchanged. A model trained in one frame can keep everything in the map. Weights read through four frames at once must serve all four, and what the frames share is the relationships.

If training moves what the weights learn into those relationships, the layer should beat one stream on combinations or binding, and the trained weights should still work through new rotations.

How it works, nuts and bolts

Stream k turns the token's 384 numbers by a rotation A_k, stretches them, turns the 1,536 channels by a rotation B_k, folds them and turns them back; the squeeze matrix reads the mean of the four. The layer keeps the plain MLP's weights and does four times its multiply-adds. Learned full rotations would cost 1.25 million numbers per stream, more than the layer's 1.18 million weights, so the learned version learns one angle per pair of channels, 3,840 in all.

P. Plain

Study 3's plain MLP, 1,536 channels.

RS4. Four frames

Four streams, their random rotations held fixed.

RS4-learned

RS4 plus a learned turn of each pair of channels, starting at zero.

RS4-id. No turn

Four identity frames: P's function through RS4's code.

P-wide. Wide

6,144 channels, RS4's arithmetic spent on weights.

After training, each RS4 model is scored with every rotation replaced by a fresh random draw, averaged over five draws (RS4-fresh), and with every rotation set to the identity, its weights unchanged. P's weights are read through four fresh rotations too, to show what any model loses when its axes move.

The design, in one table

What counts as an answer

Scores and tests are as in study 5; on text, beats needs 0.01 nats. Across the three parts the Holm correction holds the chance of a false yes at 5 percent.

1. V1, views. RS4 beats P on unseen pairs, the shift part or the scaling part, and on that task is no worse than P-wide by 0.05.
2. V2, a new angle. Where V1 holds, RS4-fresh keeps at least half of RS4's gain over P, and beats the same models read through the identity.
3. Text, beside V1. RS4 against P (beats) and P-wide (no worse by 0.02 nats) on each source.

RS4-id must match P within 0.05, or nothing is read. If P's weights lose as much from fresh rotations as RS4's, V2 carries little. Ten failures per version are read by hand.

If RS4 matches P, four times the arithmetic bought nothing. If it matches P-wide with a quarter of the weights, it repeats a known result on compressing networks. If V1 holds and V2 fails, the gain comes from four separate solutions sharing one set of numbers.

Where to look

• The New lines section of the study page.
• The lab notebook, which asks for a member passkey.

Study 7: the transplant

Study 6 asks whether weights trained under four rotations keep working from a new angle. This study asks whether what they learned can move to another model. The trained MLP weights of every layer go from a four-stream model into a plain one, and the reverse, and stay fixed while the rest of the new model trains from a fresh start around them.

Why it matters

If what a matrix learned lives only in the map along its own axes, it serves only the model it grew up in. If part of it lives in the relationships inside the matrix, another model should be able to use it. A moved matrix held fixed tests this directly: the rest of the new model has to learn to use what it is given.

The comparison is the same move made with a plain model's weights, and with fixed weights that were never trained. A model can learn around fixed random weights: in study 3, a gated layer whose gate was held at its random start scored 0.651 on unseen pairs against 0.635 for the trained one.

How it works, nuts and bolts

The donors are study 6's finished RS4 and P models, nine starts each. A transplant copies the stretch and squeeze matrices and their offsets from every layer of a donor; a four-stream host also takes the rotations of the RS4 donor with the same start. They take part in every forward and backward pass but are never updated. Everything else, the token table, attention, the normalization steps and the output layer, starts fresh from the donor's seed number plus 100, which also sets the order of the training data, and trains for 12,000 steps.

P←RS4

A plain host around RS4's weights.

P←P

A plain host around a plain model's weights.

RS4←P

A four-stream host around a plain model's weights.

RS4←RS4

A four-stream host around RS4's weights.

P←start

A plain host around its own random starting weights, never trained.

Study 6's P and RS4 runs at the same nine starts stand for training from scratch.

The design, in one table

What counts as an answer

Scores and tests are as in study 5, paired over the nine host starts.

1. T1, the weights carry what four frames taught them. On a task, (a) P←RS4 is no worse than P←P by 0.05, and (b) RS4←RS4 beats RS4←P. Both must hold. T1 is read on every task and set beside study 6's V1 where V1 holds.

Each transplant is also compared with training from scratch, P←P with P and RS4←RS4 with RS4, by Welch's test, which allows the two groups different spreads. If a transplant is not shown to be within 0.05 of training from scratch, T1 is unresolved on that task. If P←start is shown to be within 0.05 of P←P, the trained weights carry nothing the rest of the model cannot rebuild, and T1 cannot be tested there. Ten failures per version are read by hand beside the donor's.

If (a) fails, what four-frame weights hold depends on the frames they were read through. If (b) fails while (a) holds, the weights are interchangeable, and any gain of the four-stream model comes from reading through four frames. If both fail while V1 holds, the gain comes from four separate solutions sharing one set of numbers.

Where to look

• The New lines section of the study page.
• The lab notebook, which asks for a member passkey.

The other studies

The index also lists work on orbits and the upper atmosphere and on weather and ocean imagery. Those teams will add their sections here, laid out like the studies above.