Nothing from Something: Can a Language Model Discover 0?
Abstract: AI systems based on artificial neural networks are being developed with aspirations of pushing the boundary of human mathematical knowledge. A key question for these systems is how much they can reach beyond their training data. Mathematical discovery requires a strong form of out of distribution generalization; the ability to hypothesize genuinely new - and potentially logically more powerful - mathematical structures. It has been hypothesized that language abilities support such generalizations in human cognition. In this work, we use simple arithmetic as a case study for examining how modern AI models could expand their mathematical horizons, evaluating whether these models can independently discover the concept of "zero". We show that We show that (1) LLMs of a GPT-2 size are unable to perform this generalization at test time regardless of language pretraining, but (2) models can improve substantially after training on tens or hundreds of examples of zero. Additionally, we find that language pretraining reduces the number of required examples by approximately , showing that language abilities can scaffold mathematical discovery in neural models.
Paper Prompts
Sign up for free to create and run prompts on this paper.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper asks a simple-sounding but deep question: if you teach an AI to do easy math without ever showing it the number 0, can it figure out what “zero” means on its own? The authors use this to explore a bigger idea: can AI move beyond what it has seen before to discover new math concepts, the way humans once invented zero?
The big questions
The authors focus on three main questions put in everyday terms:
- If an AI practices only with positive single-digit numbers (1–9), can it handle math problems that involve 0 at test time?
- Does giving the AI general language training first (so it knows words and grammar, but not math) help it pick up the idea of zero faster later?
- Is zero special, or would the AI struggle in the same way with other digits held out from training?
How did they test it?
Here’s the basic setup, explained simply:
- The AIs: They used “transformers” similar in size to GPT-2 (a well-known LLM), plus a smaller one. Think of these as different-sized students learning the same course.
- The training (math practice): The models were taught to solve short arithmetic problems using only single digits (like “3+4-2=5”), but never saw 0 on the left side of problems or as a final answer. They did see 0 only as the last digit of answers like 10 (so they know the symbol “0” exists).
- Language pretraining: Before the math practice, some models first read lots of regular English text (stories, articles, etc.). Crucially, the authors made a special version of this reading material that removed numbers and math symbols, so the model learned language but not math. This lets us test whether language skills alone help the model learn the idea of zero more easily later.
- Few-shot learning: After testing whether models could handle zero without any examples (zero-shot), the authors gradually gave the models a tiny number of zero-containing math examples—like 1, 2, 4, … up to 1024—to see how quickly they improved. “Few-shot” here means “learning from just a few examples.”
- Other digits and bases: To ask if zero is special, they repeated the “hold one digit out” trick for digits 1–9. They also tested base-8 (digits 0–7) to see how being near the “carry” digit affects difficulty. The “carry” digit is the highest digit in a base that triggers carrying in addition (9 in base-10, 7 in base-8).
- How they measured success: They checked whether the AI wrote the correct answer to a given problem. They also tracked how hard problems looked to the model (using a common metric called “loss”), but the main idea is: did it get the right answer?
What did they find?
Here are the main results, stated clearly:
- Without any examples of zero in training, the models failed to handle problems involving zero at test time. Even the GPT-2–sized model could not “discover” zero on its own.
- A small number of examples helped a lot. When the models were given even dozens to hundreds of zero-containing examples during training:
- With around 64 examples that included zero (less than 1% of training data), the language-pretrained model already passed 60% accuracy on zero problems.
- With about 1024 such examples (about 10% of training data), it reached over 90% accuracy.
- Language helps you learn faster. Models that had been pretrained on general English needed roughly 50% fewer zero-examples to reach the same accuracy as models without language pretraining. In other words, knowing language (even without math) made learning “zero” more sample-efficient.
- Zero is special—and so is the “carry” digit. When they held out other digits (like 4 or 6), models usually handled them better than zero. Digits in the middle (like 4 or 5) were easiest; digits at the edges (0 and 9 in base-10, or 0 and 7 in base-8) were hardest. Nine and seven (the carry digits in base-10 and base-8) were also particularly tough. A simple way to think about this: the model seems better at “interpolating” (filling in the middle of what it knows) than “extrapolating” (figuring out edge cases like 0 or the carry digit).
- Bigger open models didn’t automatically solve it. Even some larger open models (about 1 billion parameters) still didn’t “discover” zero at test time without examples, suggesting this isn’t just about making the model bigger.
Why is this important?
- Discovering new math concepts is hard—even for AIs. The fact that models struggle to invent “zero” from scratch shows how challenging true mathematical discovery can be. It’s not just about solving more problems; it’s about forming new ideas that weren’t in the training data.
- Language seems to scaffold learning. Just as words like “nothing” may help children grasp the idea of zero, general language knowledge seems to give AI a head start: it still needs examples, but fewer of them.
- Edge cases matter. Zeros and carry digits act differently from “middle” numbers. Understanding these weak spots can guide better training strategies and tests for reasoning.
What could come next?
- Better training and prompting for reasoning: Techniques like step-by-step “chain-of-thought” or giving the model a scratchpad might help it generalize to new concepts more reliably.
- Scaling and richer data: Larger models and longer training might change the picture, but this study shows that size alone isn’t a silver bullet.
- Studying how language helps: Future work could look inside the model to see what language knowledge transfers—does knowing words like “none,” “empty,” or “nothing” help the model grasp zero in math?
In short, the paper shows that today’s models don’t magically invent zero from nothing, but language experience can make them much quicker learners once they see a handful of examples. If we want AI to truly push math forward, we’ll need better ways to help it bridge the gap between familiar ideas and entirely new ones.
Knowledge Gaps
Below is a concise, actionable list of the paper’s unresolved knowledge gaps, limitations, and open questions.
- The “holdout” is incomplete: the zero token still appears during training in the ones place of answers (≈2.5% of supervised tokens). This partial exposure may confound claims about zero being unseen; a stricter split that excludes zero everywhere (including tens place of multi-digit outputs) is needed.
- For the “other digits” experiments, the paper applies the same split procedure as for zero, likely allowing the held-out digit to appear in multi-digit answers (e.g., tens place). This undermines the interpretation of “holdout” and should be quantified and eliminated in a cleaner split.
- The role of tokenizer mismatch is not isolated: arithmetic uses manual per-character tokens, whereas language pretraining used GPT-2 BPE. It is unknown whether alignment of tokenization (e.g., character-level pretraining or shared vocab) would change transfer to digits and symbols.
- Potential leakage via pretraining corpus filtering is unresolved: dates/times may remain with digits, and the word “zero” (as natural language) likely appears. The degree to which this imparts numeric priors or symbol familiarity is not quantified beyond a perplexity check.
- The mechanism by which language pretraining provides a ≈50% few-shot data reduction is unknown. Are benefits due to generic compositional biases, lexical/positional priors, or latent concepts (e.g., “nothing,” “none,” “nil”) that map onto digit 0?
- The paper does not test whether the model learns the identity law of addition for zero ( and $0+a=a$) as an abstract rule versus merely fitting observed numeric patterns. Targeted probes isolating zero’s algebraic role are missing.
- No breakdown of test performance by zero’s position (leading operand, middle operand, trailing operand) or by problem structure (presence/absence of carry, number of terms) is provided; position- and structure-specific generalization remains unclear.
- Only single-digit addition/subtraction is studied; it is unknown if the findings extend to multiplication/division, multi-digit arithmetic, negative numbers, or more abstract algebraic structures where zero has different roles (e.g., identity vs. annihilator).
- The effect of “carry” is hypothesized but not causally isolated. A controlled dataset that selectively removes carry, or holds out only carry-inducing cases, is needed to test whether carry complexity—not conceptual novelty—drives failures.
- Few-shot examples are sampled without a reported coverage policy. It is unknown which placements of zero and which algebraic contexts are most sample-efficient; active or curriculum selection strategies remain unexplored.
- Training computes loss only on the RHS (answer). It is unknown whether also supervising intermediate positions or steps (e.g., stepwise addition, scratchpad tokens) would improve conceptual generalization to unseen digits.
- Only greedy decoding is used. Whether alternative decoding (e.g., beam search or temperature sampling) or test-time reasoning prompts (chain-of-thought, self-consistency) could recover zero at test time is untested.
- The study does not evaluate modern “reasoning” training regimes (process supervision, RL, tool-use/calc calls). It is an open question whether these would enable zero discovery without few-shot exposure.
- Model scale and data scale are limited (≤1B parameters tested for zero-shot; few-shot only on 124M). Systematic scaling sweeps, including >1B parameter reasoning-tuned models, are needed to map scale-generalization curves for concept discovery.
- Architecture diversity is untested. It is unknown whether recurrent, state-space, or hybrids (neural-symbolic, program-induction) show different capacities to hypothesize new concepts like zero.
- Token frequency and embedding geometry analyses are limited to cosine similarity counts. Deeper mechanistic interpretability (feature circuits, attention patterns, linear probes) could reveal how neighbors/priors drive interpolation and where zero fails.
- The study demonstrates a net improvement with pretraining but does not determine whether benefits stem from linguistic semantics vs. general pretraining (e.g., syntax, positional inductive biases). Ablations on pretraining content (with/without “zero,” “nothing,” numerals/dates) are needed.
- The generalization metric is aggregate accuracy; finer-grained error taxonomies by error magnitude, symbol confusions, and algebraic constraint violations are not reported across seeds/runs for robustness.
- The base-8 and base-10 comparisons suggest an “edge-digit” difficulty; however, the hypothesis that models interpolate but do not extrapolate is not causally tested (e.g., by embedding regularization, contrastive training, or explicit manifold shaping).
- The work does not test explicit bridging strategies inspired by bootstrapping (e.g., mapping between the word “zero” and the symbol “0”, or learned mediators linking linguistic “nothing” to arithmetic identity).
- No curriculum-learning regimes are explored (e.g., start with contexts where zero is a placeholder/spacing symbol, then introduce identity cases), leaving open whether staged exposure changes the few-shot sample complexity.
- The few-shot transfer is measured only for filtered-pretrained vs. untrained models; it is unknown if the same data reduction holds for unfiltered-pretrained, larger, or reasoning-tuned models.
- The study does not quantify the minimal data needed to “flip” from failure to robust rule use (phase transition behavior) across seeds and architectures; formal sample-complexity characterization is missing.
- The evaluation does not separate “symbol discovery” (recognizing the token ‘0’) from “concept discovery” (using zero’s algebraic properties). Purpose-built tests that force reliance on zero’s identity property (not just numeric recomputation) are needed.
- Potential confound of dropout (0.1) during zero experiments is not ablated. It remains unknown whether regularization affects learning of rare or unseen tokens in this setting.
- The influence of training objective variants (e.g., auxiliary contrastive losses on digit embeddings, weight decay schedules, spectral norm constraints) on concept discovery is unexplored.
- No comparison to explicit program-induction baselines (e.g., neurally guided symbolic solvers) is provided; the gap between neural LMs and symbolic approaches on “zero discovery” is unknown.
- The paper does not test whether integrating external tools (calculator, formal verifier) during training or inference helps bridge the conceptual gap without explicit zero examples.
- Reproducibility details such as full code, exact data splits with leakage audits, and per-split token frequency statistics are not provided, limiting independent verification of the “zero exposure” assumptions.
Practical Applications
Immediate Applications
The paper’s findings and methods suggest several deployable actions across sectors. Below is a concise list of practical uses, with sectors, potential tools/workflows, and key dependencies/assumptions.
- Edge-case competency tests for LLMs (“Zero-like Generalization Test”)
- Sectors: AI/ML tooling, software QA
- What: Create a standardized test suite to evaluate out-of-distribution conceptual generalization (e.g., whether a model can handle “zero” or carry-digit cases it never saw in training).
- Tool/workflow: “ZeroBench” package with holdout-digit tasks (base-10 and base-8), per-digit tokenization, and evaluation scripts (loss/accuracy curves, embedding-neighbor diagnostics).
- Assumptions/dependencies: Results demonstrated on GPT-2–sized models; larger “reasoning” models may behave differently. Requires access to model embeddings.
- Few-shot “symbol seeding” patching in MLOps
- Sectors: AI product engineering, enterprise ML
- What: Add tens to hundreds of curated examples (e.g., involving zero or other edge tokens) during fine-tuning to rapidly fix performance gaps; prioritize few-shot over full retrains.
- Tool/workflow: CI/CD hook that injects small curated mini-datasets and auto-evaluates data-efficiency gains.
- Assumptions/dependencies: Benefit size depends on model and domain; reported ~50% sample reduction with language pretraining under the paper’s setup.
- Prompt-time mitigation for deployed LLMs
- Sectors: Customer support, business ops, daily-use AI
- What: For tasks likely to involve “zero-like” edge cases (e.g., invoices with $0 balance), include a handful of in-context examples that feature those cases.
- Tool/workflow: Prompt templates with 3–10 solved examples that include zero and carry scenarios to boost reliability without retraining.
- Assumptions/dependencies: Depends on context-window size and model’s in-context learning capacity.
- Carry- and zero-aware test coverage for math/code assistants
- Sectors: Software, coding assistants, education tech
- What: Ensure training and QA pipelines include explicit tests for carry operations and zero cases (the paper shows both are disproportionately hard).
- Tool/workflow: Add unit tests and synthetic datasets emphasizing carry transitions and zero in arithmetic and algorithmic tasks.
- Assumptions/dependencies: Most impactful for small or mid-sized models; chain-of-thought training may alter difficulty.
- Embedding-similarity diagnostics to assess interpolation vs. extrapolation risk
- Sectors: AI safety, interpretability, MLOps
- What: Use cosine-similarity “neighbor count” of token embeddings to flag tokens at the extremes (e.g., 0/9) that may be harder to generalize to.
- Tool/workflow: Lightweight embedding-analysis module that surfaces “low-neighbor” tokens for targeted data augmentation.
- Assumptions/dependencies: Relies on availability of stable token embeddings and consistency across training phases.
- Data filtering pipeline for numeracy-sensitive pretraining
- Sectors: Data governance, privacy, content moderation
- What: Repurpose the paper’s number/symbol filtering (e.g., converting numerals to words, removing math symbols) to control numeracy exposure or to meet privacy compliance.
- Tool/workflow: OpenWebText-style filter that removes or transforms numbers, symbols, ordinals, and units; language-detection and HTML-clean pipelines.
- Assumptions/dependencies: Multilingual adaptation needed; may degrade downstream numerical ability if over-used.
- Curriculum templates for teaching hard concepts in edtech
- Sectors: Education, edtech platforms
- What: Design lessons that pair language-based scaffolding (“nothing,” “empty,” “identity element”) with a small number of targeted numerical examples to teach zero and carry concepts.
- Tool/workflow: Micro-lessons with narrative framing plus 20–100 worked problems focusing on zero and carry transitions.
- Assumptions/dependencies: Transfer from AI findings to human learning is suggestive (bootstrapping theory) but requires pedagogical validation.
- Robotics/agent training for “absence” detection
- Sectors: Robotics, autonomous systems
- What: Apply the insight that “zero-like” states are special by adding a few supervised examples of absence (e.g., no object present) during policy or perception training.
- Tool/workflow: Add labeled “none/zero” states to datasets and evaluation suites for manipulation or inventory tasks.
- Assumptions/dependencies: Language-to-perception transfer is nontrivial; multi-modal alignment required.
- Procurement and auditing checklists for OOD edge cases
- Sectors: Government, enterprise compliance
- What: Update AI procurement/evaluation templates to explicitly test out-of-distribution conceptual leaps and require disclosure of exposure to edge-cases during pretraining.
- Tool/workflow: Add “zero-like case” and “carry-case” checkboxes and performance thresholds in model validation.
- Assumptions/dependencies: Adoption depends on standards-setting bodies and regulators.
- Dataset design patterns for math evaluation and competition training
- Sectors: Academia, AI benchmarking
- What: Incorporate holdout-digit and base-8 variants to test depth of generalization rather than just memorization or pattern-matching.
- Tool/workflow: Public benchmark kits with pre-specified holdouts and reproducible data generation/configs.
- Assumptions/dependencies: Community buy-in; larger models and reasoning prompts may change results, so variants should be included.
Long-Term Applications
The work points toward longer-horizon developments that require further research, scaling, or method innovation.
- Cross-domain “ConceptLeap” benchmarks
- Sectors: AI research, software
- What: Generalize the zero-holdout idea to other domains (e.g., identity elements in algebra, zero vectors in linear algebra, null semantics in programming, vacuum states in physics).
- Potential tools/products: ConceptLeap Suite spanning math, logic, code, and scientific reasoning.
- Assumptions/dependencies: Requires domain-specific data generators and automatic verifiers; larger models and CoT/RL training should be tested.
- Cognitive-inspired bootstrapping training
- Sectors: AI research, edtech
- What: Formalize “placeholder-to-concept” curricula that combine linguistic scaffolds with sparse examples to induce new formal concepts in models.
- Potential tools/products: Curriculum engines that schedule symbolic placeholders and then ground them via few-shot tasks.
- Assumptions/dependencies: Needs algorithmic advances and controlled studies across model scales.
- Autonomous concept invention in math and code
- Sectors: Software tools, scientific discovery
- What: Agents that hypothesize new operators/symbols, test consequences in formal systems, and adopt those that improve proof/program efficiency.
- Potential tools/products: Self-refining theorem-proving assistants; language-workbench-like operator discovery for DSLs.
- Assumptions/dependencies: Requires auto-formalization, proof checking, and exploration strategies; heavy compute.
- Interpretability: identifying “zero” and “carry” circuits
- Sectors: AI safety/interpretability
- What: Map internal mechanisms that handle identity/edge cases and carry transitions to improve robustness and debugging.
- Potential tools/products: Circuit-discovery suites focused on identity elements and boundary tokens.
- Assumptions/dependencies: Interpretability methods must scale; behaviors may differ in more advanced architectures.
- Sample-efficiency–optimized pretraining strategies
- Sectors: AI platform engineering
- What: Develop pretraining recipes that maximize downstream few-shot gains (measured as percent data reduction for new concepts).
- Potential tools/products: Pretraining KPIs and dashboards tracking “data reduction” on ConceptLeap tasks.
- Assumptions/dependencies: Requires large-scale ablations on pretraining mixtures and regularizers.
- Symbol-aware tokenization standards for math/science
- Sectors: NLP infrastructure, scientific computing
- What: Tokenization that preserves per-symbol arithmetic structure and supports identity/carry generalization without special-casing.
- Potential tools/products: Open tokenizers with math/science modes; formal benchmarks tied to tokenizer choices.
- Assumptions/dependencies: Community adoption; compatibility with existing model vocabularies.
- Synthetic data generators for edge-case semantics
- Sectors: MLOps, data engineering
- What: Automatic generators that emphasize identities, zeros, nulls, boundary values, and carry-like transitions across domains (math, code, finance).
- Potential tools/products: EdgeCaseGen libraries integrated into training pipelines.
- Assumptions/dependencies: Must avoid distributional artifacts; rigorous validation needed.
- High-stakes evaluation standards for OOD conceptual leaps
- Sectors: Healthcare, finance, policy
- What: Require proof that AI systems correctly interpret zero/none/null and identity-like cases before deployment in sensitive settings (e.g., “no drug administered,” “zero exposure”).
- Potential tools/products: Certification protocols with domain-tailored ConceptLeap tasks.
- Assumptions/dependencies: Regulatory frameworks and consensus-building necessary.
- AI–developmental science collaborations to inform pedagogy
- Sectors: Academia, education policy
- What: Use AI as a testbed to refine theories of bootstrapping and design targeted interventions for teaching early numeracy (especially zero and carry concepts).
- Potential tools/products: Evidence-based curriculum modules validated via randomized studies.
- Assumptions/dependencies: Ethical clearance, cross-disciplinary teams, classroom trials.
- Reasoning-augmented generalization research
- Sectors: AI research
- What: Investigate whether chain-of-thought, process supervision, or RL-fine-tuning enables discovery of unseen concepts (beyond few-shot).
- Potential tools/products: Benchmarks comparing purely supervised vs. reasoning-augmented training on ConceptLeap tasks.
- Assumptions/dependencies: Requires larger models and systematic ablations; may interact strongly with scale.
Notes on feasibility and transfer:
- The headline findings (failure to discover zero; ~50% few-shot data reduction via language pretraining) were demonstrated on GPT-2–sized models and simple arithmetic with per-digit tokenization. Larger models, different tokenizers, or reasoning-oriented training could change these dynamics.
- The filtered-corpus pipeline is English-centric; multilingual or domain-specific deployments will need tailored filters and normalization.
- Embedding-based diagnostics assume stable, interpretable token embeddings and may vary across architectures.
Glossary
- AdamW optimizer: An optimization algorithm that decouples weight decay from the gradient-based Adam updates to improve generalization. Example: "We minimize our objective using the AdamW optimizer with standard parameters (, weight decay )."
- algorithmic generalization: The ability of a model to learn and apply abstract procedures or rules beyond seen examples. Example: "the literature on compositional and algorithmic generalization in computational models."
- attention heads: Parallel attention mechanisms within a transformer layer that allow the model to focus on different representation subspaces. Example: "they have 12 layers, 12 attention heads, and an embedding dimension of 768 (124M parameters)."
- auto-formalization: Translating informal natural-language mathematics into a machine-checkable formal language. Example: "models for ``auto-formalization'', or the task of translating natural language mathematics into a formal language, such as Lean"
- base-8 arithmetic: Computation in the octal numeral system using digits 0–7. Example: "in the base-8 arithmetic regime."
- bootstrapping: A cognitive process where placeholder symbols scaffold the acquisition of new, more powerful concepts. Example: "humans acquire new concepts through a process of ``bootstrapping''"
- bootstrap 95% confidence interval: A nonparametric interval estimate derived from resampling the data with replacement. Example: "bootstrap confidence interval: [, ]; seeds)."
- cardinal-principle-knower: In cognitive development, a learner who understands that the last number word in counting denotes the set’s cardinality. Example: "they have become
cardinal-principle-knowers'', rather than simplyfour-knowers'' or ``five-knowers''." - carry algorithm: The elementary-school procedure for addition that propagates overflow to the next digit place. Example: "learn the ``carry'' algorithm."
- carry digit: The digit whose involvement triggers a carry operation in addition, often making generalization harder. Example: "Zero and nine (carry digit) are hardest to generalize to at test time."
- compositional generalization: Generalizing by recombining known components according to systematic rules. Example: "the literature on compositional and algorithmic generalization in computational models."
- cosine learning-rate scheduler: A schedule that varies the learning rate following a cosine curve (often with warm-up/cool-down). Example: "We use a cosine learning-rate scheduler, with warm-up."
- cosine similarity: A metric measuring the cosine of the angle between two vectors, indicating representational similarity. Example: "we compute the cosine similarity of the model's representation (embedding vector) of the held-out digit to all other digits."
- cross-entropy loss: A standard loss function for classification and language modeling that measures the difference between predicted and true distributions. Example: "We use cross-entropy loss as our training objective, and loss is computed for all tokens in the sequence."
- de-duplicated: The process of removing duplicate entries from a dataset to reduce redundancy. Example: "The creators of OpenWebText then de-duplicated the posts, and filtered out entries that were not English or valid HTML."
- decoder-only transformer: A transformer architecture that uses only the decoder stack (no encoder) for autoregressive generation. Example: "All models we consider are GPT-style decoder-only transformers"
- distilled: Produced via knowledge distillation, transferring behavior from a larger teacher model to a smaller student model. Example: "Llama-3.2-1B is distilled from larger Llama-3.1 models, and trained on up to 9T tokens of public web text and code."
- embedding dimension: The size of the vector space in which tokens are represented. Example: "an embedding dimension of 768 (124M trainable parameters)."
- End-of-Sequence (EOS) token: A special token indicating the end of a generated sequence. Example: "we append an ``End-of-Sequence'' (EOS) token to the end of the sequences so that the model learns when to finish."
- few-shot learning: Learning a new concept or task from a small number of labeled examples. Example: "we allow a specified number of ``few-shot learning'' examples to be mixed into the training dataset."
- give me N task: A developmental psychology task where a child must provide N items, testing understanding of number words. Example: "the ``give me N'' task, which requires the child to provide the experimenter with N objects."
- greedy decoding: A decoding strategy that selects the highest-probability token at each step without search. Example: "generating an answer using greedy decoding and checking if that answer is correct."
- in-context learning: The ability of a model to adapt to a new task from prompts/examples provided in the input context rather than from weight updates. Example: "The interaction of model scale with desirable attributes like few-shot / in-context learning has also been shown"
- language pretraining: Training a model on large unlabeled text corpora to acquire general linguistic knowledge before task-specific training. Example: "language pretraining reduces the number of required examples by approximately , showing that language abilities can scaffold mathematical discovery in neural models."
- Lean: A formal proof assistant and programming language used for mechanizing mathematics. Example: "such as Lean \citep{Lean}."
- manual tokenization scheme: A hand-crafted tokenization approach (e.g., ensuring each digit/symbol is a separate token). Example: "This manual tokenization scheme differs from the tokenizers used to pretrain our LLMs."
- multivariate normal: A generalization of the normal distribution to multiple dimensions with a mean vector and covariance matrix. Example: "via sampling from a multivariate normal whose mean is the mean of existing embeddings and whose covariance matches the empirical covariance of existing embeddings"
- one-sided one-sample t-test: A statistical test that evaluates whether the mean of a sample is greater (or less) than a specified value. Example: "A one-sided one-sample t-test on these per-seed means (: mean reduction ) yields ."
- OpenWebText: An open-source corpus modeled after GPT-2’s training data, sourced from Reddit-linked webpages. Example: "OpenWebText is an open-source recreation of GPT-2's training corpus, based on the methods described in their original paper"
- out of distribution generalization: Generalizing to data or structures not represented in the training distribution. Example: "Mathematical discovery requires a strong form of out of distribution generalization; the ability to hypothesize genuinely new -- and potentially logically more powerful -- mathematical structures."
- per-digit tokenization: Representing each digit as its own token to expose place-value structure to the model. Example: "Examples that contain zero (except in the ones place) are held out and tokenization is per-digit."
- perplexity: A measure of how well a probability model predicts a sample; lower values indicate better predictive performance. Example: "We measure both models' perplexity on five different randomly sampled arithmetic train datasets after language pretraining"
- process supervision: Training with supervision at intermediate solution steps rather than only on final answers. Example: "OpenAI first demonstrated the impact of process supervision (supervising each step of the model's solution) on the previously cited challenging benchmark"
- reinforcement learning-adjacent techniques: Methods closely related to RL (e.g., preference optimization, policy gradients variants) applied to model training. Example: "reinforcement learning and reinforcement learning-adjacent techniques are a natural fit for this data."
- scaling laws: Empirical regularities describing how model performance scales with compute, data, and parameter count. Example: "So-called ``scaling laws'' for LLMs have been studied and debated as such"
- The Pile: A large, diverse text dataset designed for training LLMs. Example: "Pythia-1B is trained on 300B tokens from The Pile"
- token embeddings: Learnable vector representations assigned to tokens for use in neural models. Example: "The new token embeddings are initialized via sampling from a multivariate normal whose mean is the mean of existing embeddings and whose covariance matches the empirical covariance of existing embeddings"
- weight decay: A regularization technique that penalizes large weights to discourage overfitting. Example: "Weight decay is only applied to 2-dimensional parameters; biases and LayerNorm parameters are not decayed."
- zero-shot generalization: Performing a task without having seen any task-specific examples during training. Example: "we run the same tests for zero-shot generalization, but instead of holding out zero for the test set, we remove the other digits (one to nine), each in turn."







