Do Large Language Models Perform Latent Multi-Hop Reasoning without Exploiting Shortcuts?

🎯 Pitch

LLMs appear to perform latent multi-hop reasoning, but this ability collapses for queries involving years—dropping from 80% to just 5% composability when models cannot exploit co-occurrence shortcuts from pretraining data. The study reveals a stark gap between latent and explicit reasoning, showing that even the best models fail to internally compose facts for most query types.

1. Executive Summary

This paper evaluates whether large language models can perform latent multi-hop reasoning (recalling and composing two single-hop facts without generating the intermediate bridge entity) without exploiting shortcuts from entity co-occurrences or frequency-based priors in pretraining data. Using a carefully constructed dataset called SOCRATES (SHORTCUT-FREE LATENT REASONING) containing 7,232 test cases across 17 relation composition types, the authors assess 41 LLMs from 9 model families on queries like "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of." The experiments reveal that latent composability varies dramatically by bridge entity type—reaching over 80% for country-type queries in the best models but dropping to roughly 6% for year-type queries—and that shortcut-free evaluation is critical, as overlooking shortcuts overestimates latent composability by approximately 3×. The paper establishes a substantial gap between latent and Chain-of-Thought composability (e.g., GPT-4o achieves 92.8% with CoT versus 7.6% latently), demonstrating that models can perform latent multi-hop reasoning without exploiting shortcuts only for specific query types, with the ability emerging incrementally during pretraining and improving only marginally with model scale.

2. Context and Motivation

The Core Problem: We Don't Know If LLMs Truly Reason Latently Across Multiple Hops

The central question this paper tackles is deceptively straightforward: when an LLM answers a multi-hop factual query without generating intermediate reasoning steps, is it genuinely composing two separately learned facts, or is it exploiting shortcuts? This distinction matters profoundly for both how we understand LLM capabilities and how we deploy them safely.

Consider a query like "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of." To answer this correctly without Chain-of-Thought, a model must: (1) recall that Scarlett Johansson was born in 1984 (first hop), (2) recall that the 1984 Summer Olympics were hosted in the United States (second hop), and (3) compose these facts to output "the United States"—all without ever generating "1984." This process, termed latent multi-hop reasoning, requires the model to internally construct a representation of the bridge entity ("1984") and use it to retrieve the second fact.

But here's the problem: the model could produce the correct answer without doing any of this. If it encountered training sequences where "Scarlett Johansson" and "United States" frequently co-appear—in a biography, a news article about American celebrities, or even a list of famous Americans—it might learn a direct association between the head entity and the answer entity. This is a subject-object shortcut. Alternatively, if the model has learned that queries containing "hosted in the country of" typically resolve to "the United States" (because the US frequently hosts major events), it might guess based on a relation-object shortcut. In either case, the model produces the right answer for the wrong reason, bypassing the very reasoning process we claim to be evaluating.

This gap between apparent and genuine reasoning ability is what the paper addresses. Prior to this work, the field lacked a rigorous methodology for distinguishing between these scenarios when evaluating pretrained LLMs on their own parametric knowledge—the facts they learned during pretraining, not facts provided in context.

Why This Problem Matters: Scientific Understanding, Safety, and Practical Deployment

The paper identifies three distinct motivations that make this question urgent (Section 1):

1. Knowledge localization and controllability. If LLMs genuinely compose facts latently, it implies they learn compressed representations of individual facts and a mechanism for composing them—rather than memorizing every possible multi-hop combination as a separate piece of knowledge. This has direct implications for model editing and unlearning. Research on knowledge editing (Meng et al., 2022; Hong et al., 2024) attempts to modify specific facts in a model's parameters. If a model has redundantly memorized all multi-hop combinations of facts rather than composing them from primitives, editing a single-hop fact (e.g., changing a person's birth year) would fail to propagate to the corresponding multi-hop queries. This propagation failure has been documented empirically (Onoe et al., 2023; Zhong et al., 2023; Cohen et al., 2024; Ju et al., 2024). Confirming that LLMs can latently compose facts would provide evidence that locate-then-edit approaches are targeting the right representational structure; finding that they cannot would suggest that more fundamental architectural or training changes are needed.

2. Safety through transparency. Latent reasoning is, by definition, opaque. Unlike Chain-of-Thought reasoning, which produces an interpretable trace of intermediate steps, latent reasoning leaves no visible record of how the model arrived at its answer. From a safety perspective, this creates a monitoring gap (Berglund et al., 2023; Treutlein et al., 2024; Chan et al., 2024). If models can spontaneously develop latent multi-hop reasoning during pretraining—combining facts they learned from different training sources without any explicit supervision to do so—then they may be engaging in non-transparent inferences that are difficult to detect or audit. Understanding when and how this ability emerges is essential for assessing the trustworthiness of deployed systems, particularly in high-stakes domains where knowing the provenance of an answer matters.

3. Inference efficiency. Chain-of-Thought reasoning improves accuracy on complex tasks (Kojima and Gu, 2022) but at the cost of generating potentially hundreds of additional tokens. If models can perform equivalent reasoning latently—without the intermediate token generation—it could dramatically reduce inference costs and latency. However, this efficiency gain is only valuable if the latent reasoning is correct. If latent reasoning is unreliable or limited to specific query types, systems must either fall back to explicit CoT (sacrificing efficiency) or risk silent errors (sacrificing reliability). Quantifying exactly when latent reasoning works and when it fails has direct operational implications.

Conflicting Signals in Prior Work

The paper is motivated by a fundamental tension in the literature. Several prior studies have suggested that pretrained LLMs can perform latent multi-hop reasoning. Ofir Press et al. (2023) introduced the "Compositional Celebrities" dataset, constructed by concatenating facts about celebrities (birthplace, birthdate, occupation) drawn from Wikidata, and found that models could compose these facts to answer multi-hop questions. Yang et al. (2024b) probed for latent bridge entity representations in model hidden states and found evidence that models construct these representations while processing multi-hop queries. Biran et al. (2024) and Li et al. (2024) conducted similar analyses and reached broadly consistent conclusions.

However, none of these studies adequately addressed the possibility of shortcut exploitation. The paper identifies several specific ways in which prior evaluations were vulnerable:

Subject-object shortcuts from entity co-occurrence. The most fundamental gap is that prior datasets did not control for whether the head entity (e1) and answer entity (e3) had co-occurred in the model's pretraining data. If "Scarlett Johansson" and "United States" appeared together in any pretraining document, the model could learn a direct association that would produce correct answers without multi-hop composition. The paper demonstrates the severity of this gap by analyzing the Compositional Celebrities dataset (Ofir Press et al., 2023) against Dolma v1.5 (a publicly available pretraining corpus): 85.30% of its test queries contain head and answer entities that co-occur in Dolma documents (Table 2). For 7 out of 17 relation categories, this figure exceeds 95%, and three categories are entirely unusable with a 100% co-occurrence rate. This is a conservative estimate—using all possible entity aliases and additional corpora would likely increase these numbers.

Relation-object shortcuts from frequency-based priors. Even when head and answer entities never co-occur, models can exploit the answer distribution conditioned on the relation pattern alone. A classic example from Elazar et al. (2022): when asked about "the country of" something, models may disproportionately predict "United States" because it is the most frequent country entity in the training distribution, regardless of what the subject is. For multi-hop queries, this becomes even more complex: the composed relation pattern (e.g., "In the birth year of [PERSON], the [EVENT] was hosted in the country of") may trigger priors that are independent of the specific person being queried. Biran et al. (2024) addressed this partially by checking for relation-object shortcuts, but their analysis did not simultaneously account for subject-object shortcuts, and their dataset construction approach left both types of shortcuts potentially exploitable.

Assumption-based filtering rather than empirical grounding. Ofir Press et al. (2023) relied on heuristic assumptions about which multi-hop combinations were unlikely to appear in training—for instance, combining facts about relatively obscure celebrities with events that occurred in their birth years. However, these assumptions were not verified against actual pretraining corpora. As the paper's co-occurrence analysis shows, even combinations that seem unlikely can appear in training documents (e.g., a Wikipedia article about a Nobel Prize winner that mentions other laureates born in the same year). The failure to empirically ground the shortcut-exclusion criteria to actual training data statistics makes prior results uninterpretable: we cannot know whether observed performance reflects genuine composition or unrecognized memorization.

The fine-tuning alternative does not answer the target question. Several studies have sidestepped the shortcut problem by fine-tuning models on synthetic or counterfactual fact compositions and evaluating on held-out compositions (Jiang et al., 2022; Kassner et al., 2020; Allen-Zhu and Li, 2023; Saparov et al., 2023; Hou et al., 2023; Berglund et al., 2023; Petty et al., 2024; Treutlein et al., 2024; Wang et al., 2024). While these experiments provide valuable insights into the capacity for compositional generalization under controlled conditions, they do not address the question this paper asks: does latent multi-hop reasoning over factual knowledge naturally emerge during pretraining? Fine-tuning introduces potential confounds—it can encourage hallucinations (Gekhman et al., 2024), alter how models utilize existing knowledge (Kang et al., 2024), or even reduce knowledge retention (Yin et al., 2023). The behavior observed after fine-tuning may not reflect the capabilities that develop organically through language modeling on natural text.

Algorithmic and mathematical reasoning is a different problem. Studies on latent compositional reasoning for algorithmic tasks (Dziri et al., 2023; Chen et al., 2023; Deng et al., 2024) evaluate a fundamentally different capability: reasoning over rules, procedures, or patterns that are learnable from structured data. Factual knowledge—knowing that Scarlett Johansson was born in 1984 and that the 1984 Summer Olympics were in the United States—depends on memorizing specific world facts from diverse, unstructured text. The mechanisms for composing memorized facts may be different from those for composing learned procedures, and the shortcut problems (entity co-occurrence, frequency priors) are specific to the factual setting.

How This Paper Positions Itself

The paper positions itself not as proposing a new model or training technique, but as establishing the methodological framework for rigorous evaluation of latent multi-hop reasoning in pretrained LLMs. The core contribution is a set of desiderata (Section 3) that any valid evaluation must satisfy, and a dataset and evaluation procedure that operationalize these desiderata.

Desideratum 1: Latent, not explicit, reasoning. The evaluation must ensure the model is not performing explicit multi-step generation. This means excluding cases where the model generates the bridge entity before the final answer—effectively performing Chain-of-Thought despite instructions not to.

Desideratum 2: Shortcut-free evaluation. The evaluation must exclude two categories of shortcuts:

Subject-object shortcuts: cases where the head entity (e1) and answer entity (e3) co-occur in the model's pretraining data, allowing direct association.
Relation-object shortcuts: cases where the model can guess the answer based on the relation pattern alone, without considering the specific head entity. This is operationalized by checking whether the model correctly answers an ablated query where the head entity and its descriptive mention are removed (e.g., "In the year, the Summer Olympics were hosted in the country of").

The paper's approach to satisfying these desiderata without access to proprietary pretraining data is methodologically novel. Rather than assuming what LLMs have or haven't seen, the authors:

Use a 4.8B-document proxy corpus drawn from six publicly available training corpora (Dolma v1.5 and v1.7, Tulu v2, OSCAR, C4, and OpenWebText) to approximate document-level co-occurrences. By only including test cases where the head and answer entities never co-occur in any document across these 4.8B documents, they impose a highly conservative filter. This approximation is validated by showing that applying an even more aggressive Google Search filter (covering approximately 400B indexed documents) produces only a minimal drop in measured latent composability (an average relative decrease of 0.03, described in Appendix C.3).
Construct ablation-based guessability tests (following Biran et al., 2024) where they measure whether the model can answer the query when the specific entity information is removed. Test cases where the model succeeds on these ablated queries are excluded, as they indicate the model is exploiting relation-object patterns rather than using the head entity.
Systematically select fact compositions where the head and answer entities are unlikely to be associated through alternative single-hop relations (e.g., excluding cases where the event country in the multi-hop query happens to be the person's birth country). This prevents the composition from collapsing into a simpler inference.

The paper's position is that without these controls, evaluations of latent multi-hop reasoning are uninterpretable. The comparative experiment in Section 6.3 (Figure 4) drives this home: when the same models are evaluated on a shortcut-prone dataset (matched for relation composition distribution but without co-occurrence filtering or guessability checks), latent composability appears roughly 3× higher than on SOCRATES with shortcut-free evaluation. This gap is consistent across all 41 models tested (Appendix Figure 10), confirming that prior work likely overestimated the prevalence of latent multi-hop reasoning.

The paper also positions itself as bridging two largely separate lines of work: (1) the factual knowledge probing literature, which has documented shortcut vulnerabilities in single-hop factual recall (Elazar et al., 2022; Kang and Choi, 2023; Zhang et al., 2024b), and (2) the multi-hop reasoning evaluation literature, which has not systematically applied those insights to control for shortcuts. By extending the shortcut taxonomy from single-hop to multi-hop settings and providing empirical evidence that these shortcuts are widespread in existing datasets, the paper establishes that shortcut-free evaluation is not just a methodological nicety but a prerequisite for meaningful measurement.

Finally, the paper importantly does not claim to have fully solved the problem of latent reasoning evaluation. The authors acknowledge that their proxy corpus cannot guarantee completeness—it's possible that some test cases in SOCRATES still contain head-answer co-occurrences in models' actual (undisclosed) pretraining data. The paper's claim is that it provides the tightest approximation possible without access to proprietary training corpora, and that the resulting measurements represent a significantly more reliable lower bound on true latent multi-hop reasoning ability than anything previously available.

3. Technical Approach

3.1 Reader Orientation

This is a dataset construction and evaluation methodology paper whose core artifact is SOCRATES, a carefully filtered set of 7,232 multi-hop factual queries designed to evaluate whether LLMs can internally compose two separately learned facts without generating intermediate reasoning steps—and without relying on statistical shortcuts from entity co-occurrences or frequency-based priors in pretraining data. The system solves the problem of uninterpretable evaluation: prior benchmarks could not distinguish between genuine latent multi-hop composition and shortcut exploitation because they failed to control for whether the head and answer entities had appeared together in training documents, or whether models could guess the answer from the relation pattern alone. SOCRATES addresses this through a three-stage pipeline that (1) selects fact pairs unlikely to co-occur naturally, (2) constructs diverse natural-language query templates, and (3) aggressively filters using document-level co-occurrence statistics from a 4.8B-document proxy corpus, coupled with an evaluation procedure that excludes guessable queries and forces the model to answer without generating the bridge entity.

3.2 Big-Picture Architecture (Diagram in Words)

The overall system has five major components, arranged in a sequential pipeline from raw knowledge graph facts to final latent composability measurements:

Fact Pair Selection Module — queries Wikidata for pairs of single-hop facts sharing a bridge entity, applies relation-specific heuristics to exclude compositions where the head and answer entities are likely to be directly associated through alternative relations or where the bridge entity is trivially inferrable from the head entity name. Produces approximately 100K candidate (e1, e2, e3, r1, r2) tuples with entity aliases.
Query Template Engine — converts each fact pair into three natural-language queries (two single-hop, one multi-hop) using handcrafted templates (16 per relation composition type). Templates are designed as incomplete sentences (fill-in-the-blank format) rather than questions, enabling direct completion by any pretrained model without fine-tuning or in-context examples.
Co-occurrence Filter — uses the WIMBD API against a proxy corpus of approximately 4.8B unique documents (Dolma v1.5, Dolma v1.7, Tulu v2, OSCAR, C4, OpenWebText) to compute document-level co-occurrence counts for every alias combination of the head entity e1 and answer entity e3. Discards any test case where any alias pair co-occurs in any document. This is the primary mechanism for satisfying Desideratum 2 (subject-object shortcut exclusion).
Evaluation Harness — for each model being evaluated, administers all three queries (two single-hop, one multi-hop) with CoT-suppressing instructions, applies exact-match scoring with string normalization, and records correctness. Additionally administers ablated versions of multi-hop queries (with head entity information removed) to detect relation-object shortcuts, and checks whether the model generated the bridge entity before the answer (indicating explicit rather than latent reasoning).
Composability Calculator — computes latent composability as the fraction of test cases where the model correctly answers all three queries (both single-hop and the multi-hop), excluding cases that are guessable (model succeeds on ablated queries), unusable (model generates bridge entity or enumerates answer options), or where either single-hop fact is unknown. For model comparisons, computes comparative latent composability using the intersection of test cases where all compared models know both single-hop facts and no model has guessable/unusable behavior.

Information flows linearly: Wikidata facts → template-based query generation → co-occurrence filtering → model inference on all query variants → correctness scoring → composability calculation. The critical design principle is that filtering decisions are made based on empirical co-occurrence statistics, not assumptions—the pipeline does not guess what models might have seen; it checks against actual document collections and removes cases accordingly.

3.3 Roadmap for the Deep Dive

First, the fact pair selection process (Section 4.1, Step 1) — because the quality of the dataset fundamentally depends on starting with fact compositions where shortcuts are structurally unlikely, not just filtered out post-hoc. This includes the Wikidata schema, the relation types chosen, and the heuristic exclusion rules.
Second, the query template construction (Section 4.1, Step 2) — because the surface form of queries affects both what models can answer and what shortcuts they can exploit, and the template sampling strategy determines the diversity and coverage of the evaluation.
Third, the co-occurrence-based filtering (Section 4.1, Step 3) — the linchpin of the entire approach. This includes the proxy corpus composition, the WIMBD API mechanism, the document-level vs. sequence-level approximation, and the validation via Google Search.
Fourth, the evaluation procedure (Section 5) — covering the guessability exclusion (ablated queries), the unusability exclusion (bridge entity generation detection), the CoT-suppressing instruction design, the exact-match scoring with normalization, and the latent composability metric definition.
Fifth, the comparative latent composability framework (Section 5.2) — the method for fair model comparison when different models know different subsets of single-hop facts, and the cross-model intersection logic.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a dataset construction and evaluation methodology paper whose core idea is that latent multi-hop reasoning can only be meaningfully measured when the evaluation systematically excludes two classes of shortcuts: subject-object associations from entity co-occurrence in pretraining data, and relation-object associations from frequency-based priors in the answer distribution. The technical contribution is the pipeline that operationalizes these exclusions without requiring access to any specific model's pretraining data.

Fact Pair Selection: Starting from Wikidata

The pipeline begins by selecting pairs of single-hop facts from Wikidata that share a bridge entity and are structurally likely to require genuine composition—meaning the head and answer entities are not directly connected through alternative single-hop relations, and the bridge entity is not trivially inferrable from the head entity's surface form.

Wikidata as the knowledge source. The authors use Wikidata (Vrandečić and Krötzsch, 2014) as the underlying knowledge graph G, where facts are represented as subject-relation-object triplets ⟨s, r, o⟩. For each pair of triplets that share a common entity—⟨e1, r1, e2⟩ and ⟨e2, r2, e3⟩—the composition r2 ◦ r1(e1) = e3 forms a candidate multi-hop fact. The entities e1, e2, and e3 are the head entity, bridge entity, and answer entity respectively, and each is associated with a set of aliases E1, E2, E3 drawn from Wikidata—these alias sets are crucial because they determine which co-occurrences are checked during filtering.

Relation selection criteria. The authors select 11 types of r1 and 10 types of r2 that combine into 21 initial relation composition types (reduced to 17 after filtering). The selection is guided by several principles designed to minimize the chance that e1 and e3 are naturally associated:

Large option space for e2: The set of possible values for the bridge entity should be large, making it unlikely that models can guess e2 without knowing the specific fact. This eliminates relations like person-bloodtype where the answer space is trivially small (A, B, AB, O).
Many-to-one mapping from e1 to e2: Many different head entities should map to the same bridge entity value. For instance, thousands of people were born in 1984, so knowing that someone was born in 1984 does not uniquely identify them—and conversely, knowing a person does not trivially determine their birth year without factual recall. This property ensures that the bridge entity genuinely needs to be recalled, not inferred from the head entity alone.
Non-trivial answer space for e3: The set of possible answers should not be so small that random guessing achieves non-negligible accuracy (Desideratum 2).
Temporal stability: Relations subject to frequent change over time (e.g., organization-CEO, person-spouse) are excluded to ensure fair comparison across models with different knowledge cutoff dates. This means the dataset is built from relatively stable facts like birth years, national anthems, Nobel Prize winners, and Olympic host cities.

The 17 relation composition types. After filtering, SOCRATES contains compositions organized by bridge entity type, as shown in Table 1:

Country-type bridge entities (7 sub-types, 166 test cases): These connect two facts through a country, such as university-locationcountry-anthem (University X → country Y → national anthem Z) or person-birthcountry-anthem (Person X → birth country Y → national anthem Z). The total includes university-locationcountry-anthem (101 cases), university-locationcountry-isocode (30 cases), person-birthcountry-anthem (22 cases), university-locationcountry-year (7 cases), and person-birthcountry-isocode (6 cases).
City-type bridge entities (1 sub-type, 33 cases): person-birthcity-eventyear connects a person's birth city to the year a specific event (Eurovision, Olympics, G7 Summit, European Capital of Culture) was hosted there.
University-type bridge entities (2 sub-types, 58 cases): person-undergraduniversity-founder (33 cases) and person-undergraduniversity-year (25 cases) connect a person's undergraduate university to its founder or founding year.
Year-type bridge entities (7 sub-types, 6,975 cases): By far the largest category, these connect a year (typically a birth year or founding year) to an event's host location or winner. Sub-types include person-birthyear-winner (4,484 cases—the largest single category), person-birthyear-eventcity (1,389 cases), person-birthyear-hostleader (260 cases), person-birthyear-eventcountry (124 cases), university-inceptionyear-winner (632 cases), university-inceptionyear-eventcity (62 cases), and smaller sub-types for specific event-year combinations.

The heavy skew toward year-type bridge entities is not a design choice but a direct consequence of the co-occurrence filtering: most test cases with country, city, or university bridge entities are eliminated during filtering because the head and answer entities frequently co-occur in documents. This distributional skew is itself an important finding—it reveals that certain fact compositions (especially those involving countries) are much harder to find in a truly shortcut-free form than others.

Heuristic exclusion rules (Appendix A.1, Table 3). Before co-occurrence filtering, the authors apply relation-specific heuristics to exclude cases where e1 and e3 are likely connected through an alternative single-hop relation that would make the composition trivial. For example, for person-birthyear-eventcountry queries (e.g., "The country where the Eurovision Song Contest took place in the birth year of e1 is"), they exclude cases where the event country matches the person's birth country—because then the model could answer via the direct single-hop relation person-birthcountry(e1) = e3 without composing through the birth year. For person-birthyear-winner queries, they exclude cases where the person's birth or citizenship country matches the winner's birth or citizenship country. For university-inceptionyear-winner queries, they exclude cases where the university is the winner's alma mater or where the university's location country matches the winner's country. These heuristics operationalize the requirement that the multi-hop query should not collapse into an easier inference.

Bridge entity inferrability filtering (Appendix A.3). For relations where the bridge entity can be guessed from the surface form of e1 (most critically university-locationcountry and person-birthcountry), the authors use a secondary filtering step. They query GPT-3.5 Turbo and Claude 3 Haiku with prompts asking them to guess the country solely from the entity name (e.g., "Guessing from the name, what are the candidates of the country where 'The University of Washington' is likely to be located? ... Make sure to list the names of the countries guessed solely from the name."). If either model correctly identifies the bridge entity country, the test case is excluded. This ensures that for the remaining cases—such as university-locationcountry(The International Graduate School of English) = South Korea or person-birthcountry(Natalie Portman) = Israel—the bridge entity requires factual knowledge rather than name-based inference.

Quality assurance filtering (Appendix A.4). Additional heuristic filters remove cases with non-natural-language Wikidata titles, non-unicode characters, double quotation marks or slashes in entity names, country flag emojis in aliases, and cases where any entity is a substring of another (which would cause false positives in exact-match scoring). HTML characters are escaped and normalized. Cases where all open-source LLMs fail to correctly answer either single-hop query are discarded, as this indicates either errors in the Wikidata alias set or facts that are simply not well-known enough to be in any model's parametric knowledge.

After all these steps, approximately 100K candidate tuples remain, which are then subjected to the co-occurrence filter that dramatically reduces the count to the final 7,232.

Query Template Construction: From Triplets to Natural Language

Each fact pair must be converted into natural-language queries that can be presented to pretrained LLMs without fine-tuning. The design space here involves tradeoffs between coverage (using diverse templates to avoid overfitting to specific phrasings), control (ensuring the multi-hop query genuinely requires both facts), and avoiding introduction of new shortcuts.

Template format. All queries are constructed as incomplete sentences (fill-in-the-blank) rather than questions. The paper explicitly states this choice: "We construct the queries as incomplete sentences, instead of questions, so that the test query can be naturally completed by any pretrained model to derive the answer without finetuning." This format is important because pretrained models (as opposed to instruction-tuned models) are trained on next-token prediction over natural text continuations, not on question-answering. A fill-in-the-blank format ("In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of ___") is a more natural continuation task than a question format ("In what country were the Summer Olympics hosted in the year Scarlett Johansson was born?").

Template per relation. For each relation composition type, the authors manually construct 4 natural language templates for each single-hop relation r1 and r2. Since the multi-hop query is formed by combining a template for r1 (to create the descriptive mention of the bridge entity) with a template for r2 (to frame the final question), this yields 4 × 4 = 16 possible templates for each relation composition type. At dataset creation time, one template is randomly sampled for each test case.

Example templates. For the person-birthyear-winner relation composition (e.g., person-birthyear-nobelphysics), r1 templates for the first hop (birth year) might include:

"The birth year of e1 is"
"e1's year of birth is"
"e1 was born in the year"
"In the year, e1 was born"

And r2 templates for the second hop (Nobel Prize winner in that year) might include:

"In e2, the Nobel Prize in Physics was awarded to"
"The winner of the Nobel Prize in Physics in e2 is"
"In the year e2, the laureate of the Nobel Prize in Physics was"
"The Nobel Prize in Physics in e2 went to"

A multi-hop query then combines one r1 template (as a descriptive mention replacing e2) with one r2 template, producing queries like "In e1's year of birth, the Nobel Prize in Physics was awarded to" or "The winner of the Nobel Prize in Physics in the year e1 was born is."

Single-hop queries. Two single-hop queries are constructed for each test case:

q(r1(e1)): Takes the form "descriptive mention of bridge entity + is" and takes E2 (the bridge entity alias set) as the answer set. For example, "The year Scarlett Johansson was born in is ___" expects "1984."
q(r2(e2)): Constructed by feeding the bridge entity directly into an r2 template, taking E3 as the answer set. For example, "In 1984, the Summer Olympics were hosted in the country of ___" expects "the United States."

The single-hop queries serve two purposes: (1) they verify that the model actually knows the constituent facts (a prerequisite for claiming that multi-hop success reflects composition of known facts), and (2) they are used in the composability denominator to condition on known facts.

Multi-hop query. q(r2 ◦ r1(e1)) is constructed by embedding the descriptive mention of the bridge entity (using an r1 template) into an r2 template, yielding "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of ___." The answer set is again E3.

Why 16 templates per type. The template diversity is a deliberate design choice to prevent models from exploiting template-specific surface patterns. If only a single template were used, a model might learn to associate the specific string pattern with particular answers (a form of relation-object shortcut at the template level). By randomizing across 16 template combinations, the evaluation reduces the chance that success is driven by memorized template-answer associations rather than genuine fact composition.

Co-occurrence-Based Filtering: The Core Shortcut Exclusion Mechanism

This is the most technically critical component of the pipeline. The goal is to ensure that for every test case in SOCRATES, the model cannot have developed a direct association between e1 and e3 through seeing them together in pretraining. The challenge is that most LLMs' pretraining data is proprietary and inaccessible, making direct verification impossible.

The approximation strategy. The authors use two simplifications to make the problem tractable:

Document-level rather than sequence-level co-occurrence. Instead of checking whether e1 and e3 appear in the same training sequence (typically a subsequence of a document, often 2048–8192 tokens), they check whether they appear in the same document. This is a stricter condition: if e1 and e3 never co-occur in any document, they certainly never co-occur in any training sequence (since training sequences are substrings of documents for most LLMs trained with document boundary handling, which is the standard approach identified by Zhao et al., 2024). Filtering at the document level is conservative—it removes some cases where e1 and e3 appear in the same document but different sequences (which would not create a shortcut), but it never allows through a case where they do co-occur in a sequence.
Proxy corpus rather than model-specific pretraining data. Since the exact pretraining corpora of proprietary models are unknown, the authors use a union of six publicly available training corpora that collectively contain approximately 4.8 billion unique documents. The corpora and their sizes are:
- Dolma v1.5: 4,367 million documents (used to train OLMo)
- Dolma v1.7: 2,532 million documents (used to train OLMo 0724)
- OSCAR: 432 million documents (used to train BLOOM)
- C4: 365 million documents (used to train T5)
- Tulu v2: 326,000 documents (used to train OLMo Instruct)
- OpenWebText: 8 million documents (used to train GPT-2)
The total of approximately 4.8B unique documents reflects deduplication across corpora: 4,367M (Dolma v1.5) + 432M (OSCAR) + 8M (OpenWebText) - 10M (estimated OSCAR-Dolma overlap based on WIMBD statistics), yielding roughly 4.8B distinct documents. Tulu v2 and C4 are mentioned as contributing unique documents as well, though the paper notes that the Tulu v2 overlap with Dolma is not separately quantified.

Implementation via WIMBD API. The authors use the WIMBD (What's In My Big Data) API (Elazar et al., 2024) to query document co-occurrence counts across these corpora at scale. WIMBD uses Elasticsearch (Banon, 2010) as its backend with case-insensitive string matching. The API takes a pair of strings and returns the number of documents in each indexed corpus where both strings appear.

The filtering procedure. For each candidate test case, the authors check all possible combinations of aliases of e1 and e3. An alias combination is a pair (a1, a3) where a1 ∈ E1 (the set of names by which e1 is known) and a3 ∈ E3 (the set of names by which e3 is known). If any alias pair has a non-zero document co-occurrence count in any of the proxy corpora, the entire test case is discarded. This means a single test case with, say, 3 aliases for e1 and 4 aliases for e3 requires checking 12 alias pairs—and any one positive match triggers exclusion.

Scale of the filtering. The filtering is severe. Starting from approximately 100K candidate test cases after the heuristic filtering steps, only about 32K survive the co-occurrence filter. Further down-sampling of year-type bridge entity cases (which dominate the survivors) yields the final 7,232 test cases. The dramatic reduction—approximately 68% of candidates eliminated—demonstrates that entity co-occurrence in pretraining data is pervasive: for most plausible fact compositions, the head and answer entities have appeared together somewhere in the 4.8B-document corpus. This is not a bug but a finding: it quantifies how difficult it is to construct genuinely shortcut-free multi-hop queries.

The resulting distributional skew. Different relation composition types survive filtering at very different rates, producing the imbalanced dataset shown in Table 1. Year-type bridge entity queries survive much more often than country-type queries because events occurring in specific years (Nobel Prize ceremonies, Olympic Games, etc.) naturally co-occur with the names of notable people born in those years less frequently than countries co-occur with their own national symbols, universities, or citizens. This skew is not a limitation of the methodology but a reflection of a real property of natural text: some types of fact compositions are inherently harder to find in shortcut-free form.

Validation via Google Search (Appendix C.3). To validate that the 4.8B-document proxy corpus provides a sufficiently tight approximation, the authors conduct an additional experiment on the country-type bridge entity queries (where latent composability is highest, making it the subset where any remaining co-occurrence would be most concerning). They apply a Google Search filter: for each test case, they check whether the head and answer entity names appear together in any of approximately 400 billion documents indexed by the Google Search Engine. Cases with any Google co-occurrence are removed. Since this aggressive filtering reduces the denominator so much that only five models have sufficient remaining test cases for measurement, the authors report the average relative drop in latent composability:

$\text{Average Relative Drop} = \mathbb{E}\left[\frac{c - c'}{c}\right]$

where c is the latent composability measured on the country-type subset without the Google filter and c' is the latent composability measured on the further-filtered subset that additionally excludes Google co-occurrences.

What it computes: for each of the five models with sufficient data, it computes how much the composability score decreased (as a fraction of the original) after the extra filtering. The expectation averages this relative decrease across models.

Why this form: a relative measure is appropriate because different models have different baseline composability values, and we want to know whether the filtering causes a proportional drop that might indicate remaining shortcuts. A small average relative drop would suggest that the proxy corpus filtering already eliminated most co-occurring cases.

The result: the average relative drop is 0.03, meaning composability decreases by only 3% on average even after excluding all Google-co-occurring cases. The authors interpret this as evidence that the proxy corpus approximation is effective—the additional filtering barely moves the needle, suggesting that most entity co-occurrences that exist on the web are already captured by the 4.8B-document corpus. This is a crucial validation for the methodology's credibility, since it directly addresses the concern that the proxy corpus might be insufficiently comprehensive.

Relationship to Desideratum 2. The co-occurrence filter directly addresses the subject-object shortcut component of Desideratum 2: by ensuring that no alias of e1 and e3 co-occurs in any document across 4.8B documents, it makes it extremely unlikely (though not impossible—a limitation the paper acknowledges) that the model has formed a direct association between the head and answer entities through co-occurrence in pretraining.

Evaluation Procedure: Measuring Latent Composability Without Shortcuts

Once the dataset is constructed, the evaluation procedure applies additional filtering at inference time to ensure that (a) the model is genuinely performing latent (not explicit) reasoning, and (b) the model is not exploiting relation-object shortcuts. These run-time checks complement the dataset-level co-occurrence filter to provide a comprehensive shortcut-exclusion framework.

CoT-suppressing instruction. Instruction-tuned LLMs tend to generate Chain-of-Thought reasoning by default when faced with complex queries. To force latent reasoning, the authors use a specific prompt:

"Fill in the blank. Write down only what goes in the blank. Do not explain your answer. The answer can consist of multiple words."

This is appended before the query, which ends with " ___" to indicate a fill-in-the-blank format. The authors state this prompt was selected because it "most effectively prevented the CoT-style reasoning among several different task formulations that have been manually tested." For models that support custom system instructions (Claude, GPT, Mistral, Qwen), the instruction is provided as the system instruction; for other models, it appears at the beginning of the prompt followed by "\n\n".

Why not few-shot learning? The paper notes that while it is possible to use few-shot demonstrations to restrict answer format (as done by Ofir Press et al., 2023), they choose instruction-based format control "to avoid potential biases in the selection of the few-shot demonstrations." Different choices of exemplars could bias the model toward particular answer patterns or trigger different internal behaviors, and controlling for this adds unnecessary complexity when a simple instruction suffices.

Exact-match scoring with normalization (Appendix B.2). For each query, the model's raw completion is compared against the answer set (aliases of the target entity) using a normalized exact match score. The normalization consists of:

Lowercasing
Removing accents
Removing articles
Removing spaces in abbreviations
Replacing punctuation marks with spaces

The EM score is 1 if any answer candidate from the alias set appears in the normalized generation respecting word boundaries, and 0 otherwise. The word boundary constraint prevents partial matches: "States" would not match "United States" because "States" alone doesn't respect the word boundary of the full entity name unless the full string appears.

Excluding unusable cases (Appendix B.1). Two types of model behavior make a test case unusable for evaluating latent reasoning, even if the answer is technically correct:

Multiple-choice enumeration: When the model completes the query by listing answer options (e.g., "1. 'O Canada' 2. 'The Star-Spangled Banner' 3. 'God Save the Queen'"), this is not genuine answer production but rather a format artifact—likely because the model was trained on multiple-choice QA data. The paper observes this behavior most frequently with pretrained Qwen2 models. If either the single-hop or multi-hop query completion exhibits this pattern, the test case is excluded from composability calculations.
Bridge entity generation before the answer: For multi-hop queries specifically, if the model's completion contains any alias of the bridge entity e2 (from the set E2) before the earliest occurrence of any alias of the answer entity e3, the test case is marked as unusable. This operationalizes Desideratum 1: if the model generates the intermediate answer before the final answer, it is performing explicit rather than latent reasoning—equivalent to a short Chain-of-Thought—and cannot be used to measure latent composability. For example, completing "The name of the national anthem of the country where Rishi Bankim Chandra Colleges is based is" with "\nThe correct answer is India.\nThe national anthem of India is Jana Gana Mana" would be excluded because "India" (the bridge entity) appears before "Jana Gana Mana" (the answer entity).

Excluding guessable cases (relation-object shortcut detection). Even when the model correctly answers the multi-hop query and neither unusability condition is triggered, the answer might still reflect a relation-object shortcut rather than genuine composition. The paper operationalizes this check following Biran et al. (2024) by constructing ablated queries Q_∅ where the specific information about the head entity is removed:

q(r2 ◦ r1(∅)): The multi-hop query with e1 and r1(e1) ablated to generic placeholders. For example, "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of" becomes "In the person's year of birth, the Summer Olympics were hosted in the country of."
q(r2(∅)): The second single-hop query with e2 ablated. For example, "In 1984, the Summer Olympics were hosted in the country of" becomes "In the year, the Summer Olympics were hosted in the country of."

If the model correctly answers the multi-hop query and also correctly answers any of the ablated queries, the test case is classified as guessable and excluded from composability calculations. The logic is: if the model can answer the query without knowing the specific head entity, then its correct answer on the full query cannot be attributed to composition of the head-entity-specific facts—it could simply be exploiting the relation-object prior (e.g., "hosted in the country of" frequently resolves to "the United States" because the US hosts many international events).

Implementation note. The guessability check uses the same CoT-suppressing instruction and is administered alongside the main queries. This means the model must answer the ablated query directly, without generating intermediate reasoning, under the same format constraints—ensuring a fair comparison.

Latent Composability: The Core Metric

With all exclusions applied, latent composability is defined as a conditional probability:

$\text{Latent Composability} = \frac{|\text{correct multi-hop} \cap \text{correct } q(r_1(e_1)) \cap \text{correct } q(r_2(e_2)) \setminus \text{guessable} \setminus \text{unusable}|}{|\text{correct } q(r_1(e_1)) \cap \text{correct } q(r_2(e_2)) \setminus \text{guessable} \setminus \text{unusable}|}$

where:

correct multi-hop is the set of test cases where the model correctly answers q(r2 ◦ r1(e1)) (after unusability exclusion)
correct q(r1(e1)) is the set where the model correctly answers the first single-hop query
correct q(r2(e2)) is the set where the model correctly answers the second single-hop query
guessable is the set where the model answers any ablated query correctly
unusable is the set where the model generates the bridge entity before the answer or enumerates answer options

What it computes: the fraction of test cases where the model knows both constituent single-hop facts and successfully composes them to answer the multi-hop query, among cases where shortcuts are excluded. In operational terms: the pipeline administers all queries, checks correctness and exclusion conditions, and computes this ratio over the surviving cases.

Why this form: conditioning on known single-hop facts is essential because latent composability is meant to measure composition ability specifically, not general knowledge coverage. If a model doesn't know that Scarlett Johansson was born in 1984 or that the 1984 Olympics were in the United States, its failure on the multi-hop query tells us nothing about composition ability—it fails because the prerequisites aren't met. The denominator correct q(r1(e1)) ∩ correct q(r2(e2)) ensures that we only evaluate composition on cases where both single-hop facts are in the model's parametric knowledge. The exclusion of guessable and unusable cases ensures that success genuinely reflects latent composition rather than shortcuts or explicit reasoning.

Comparative latent composability. When comparing multiple models, a complication arises: different models know different subsets of single-hop facts, and different subsets of test cases are guessable or unusable for different models. Comparing raw latent composability would be misleading because the denominators differ. The paper addresses this by defining comparative latent composability:

$\text{Comparative Latent Composability}_{M_1, M_2} = \frac{|\bigcap_{M \in \{M_1, M_2\}} (\text{correct}_M(q(r_1(e_1))) \cap \text{correct}_M(q(r_2(e_2))) \setminus \text{guessable}_M \setminus \text{unusable}_M) \cap \text{correct}_{M_i}(q(r_2 \circ r_1(e_1)))|}{|\bigcap_{M \in \{M_1, M_2\}} (\text{correct}_M(q(r_1(e_1))) \cap \text{correct}_M(q(r_2(e_2))) \setminus \text{guessable}_M \setminus \text{unusable}_M)|}$

where the intersection ∩_{M ∈ {M1, M2}} is taken over the sets of test cases that satisfy the condition for both models.

What it computes: for a given pair of models, it identifies the subset of test cases where both models know both single-hop facts and neither model has guessable or unusable behavior. Within this common denominator, it computes the fraction where a specific model Mi correctly answers the multi-hop query. This ensures that any difference in composability between models reflects genuine differences in composition ability, not differences in which facts they know.

Why this form: without the intersection, a model that knows fewer single-hop facts could appear to have higher composability simply because it only knows "easy" facts where composition is more likely. The intersection forces evaluation on a common ground, making comparisons fair. The paper applies this for all model comparisons shown in Figures 2b, 2d, and for the model-family scaling analyses.

CoT composability. For comparison, the paper also measures CoT composability using the same denominator logic but with a different instruction that triggers explicit Chain-of-Thought reasoning:

"Fill in the blank. First, write the step-by-step explanation necessary to get the solution with the prefix 'EXPLANATION:'. After that, write down the final answer with the prefix 'ANSWER:'. For the final answer, write down only what goes in the blank. The answer can consist of multiple words."

The CoT composability metric uses the same formula but with the multi-hop query answered under this CoT-triggering instruction, without excluding cases where the bridge entity is generated (since that is the intended behavior).

Patchscopes Experiment: Probing for Latent Bridge Entity Representations

To complement the behavioral evaluation, the paper conducts a mechanistic analysis using Patchscopes (Ghandeharioun et al., 2024) to examine whether models construct latent representations of the bridge entity while processing multi-hop queries, and whether this construction correlates with successful latent composition (Section 6.3, Appendix C.4).

The Patchscopes method. Patchscopes is an activation patching technique that tests whether a hidden representation at a specific layer and token position in a "source" computation encodes a particular concept. The procedure works as follows:

Source prompt processing: The model processes the multi-hop query (the "source prompt") and we capture the hidden states at the last token of the descriptive mention of the bridge entity (e.g., "the year Scarlett Johansson was born") or at the last token of the full multi-hop query. These hidden states are candidates for containing a latent representation of the bridge entity e2 or answer entity e3.
Target prompt patching: A separate "target prompt" is constructed: "StarCraft: StarCraft is a science fiction real-time strategy game, Leonardo DiCaprio: Leonardo DiCaprio is an American actor, Samsung: Samsung is a South Korean multinational corporation, x". This prompt follows a format of "entity: entity description" where each description begins by repeating the entity name. The few-shot examples establish the pattern, and the final token "x" is where we expect the model to generate a new entity name if the patched-in representation encodes one.
Activation patching (Vig et al., 2020): At a specific layer of the target prompt computation, the hidden state at the token "x" is replaced with the hidden state captured from the source prompt at a specific layer. This means the model continues its computation on the target prompt but with a "foreign" representation injected at a particular layer and position.
Decoding: The model generates from the patched target prompt (with temperature 1.0, three independent samples) and we check whether the bridge entity e2 (or answer entity e3) appears in any of the generations.

Why this works. The target prompt's few-shot examples teach the model the format: given "entity_name:", generate a description that starts by repeating the entity name. If the hidden state at "x" contains a sufficiently clear latent representation of an entity (like "1984"), the model should generate that entity name when continuing from the patched representation. This is essentially asking: "can we decode an entity from this hidden state alone, without any other context?"

Layer-wise sweep. The experiment sweeps over all pairs of source layers (where the hidden state is taken from) and target layers (where it is patched into) using Mistral 7B v0.3. The full results are shown as heatmaps (Figure 6 in the main paper, Figure 11 in the appendix). The source layer index is on the y-axis, the target layer index on the x-axis, and the color intensity represents the extraction rate—the fraction of test cases where the bridge entity is successfully decoded from the patched representation.

Why Mistral 7B v0.3. This model is chosen because it is fully open-source (allowing layer-wise hidden state access), it is small enough for tractable activation patching across all layer pairs, and it is a pretrained (not instruction-tuned) model, avoiding the confounding effect of instruction-tuning on internal representations.

Results interpretation. For queries with country-type bridge entities (which show high latent composability), the bridge entity e2 is successfully extracted from the hidden states in many source-target layer combinations, with extraction rates reaching 0.4–0.5 in the middle-to-late layers. For queries with year-type bridge entities (which show low latent composability), the extraction rate is substantially lower—the heatmap is visibly "colder" with maximum extraction rates around 0.1–0.2. The paper interprets this as evidence that "latent representations of bridge entities are constructed more often for queries with country-type bridge entities (that have higher latent composability)," suggesting that the behavioral performance difference is reflected in the model's internal representations: when the model successfully composes facts, it first constructs a representation of the bridge entity from the descriptive mention, and when it fails, this representation may not be constructed or may be constructed too weakly to drive retrieval of the second fact.

Caveat on extraction rate interpretation. The paper notes that the extraction rate is a lower bound on how often the latent representation is constructed, because "the extraction is successful only when the latent representation of the entity emerges sufficiently clearly to be able to decode the entity only from the representation itself." A representation might encode the bridge entity in a way that is useful for downstream computation (retrieving the second fact) without being cleanly decodable as the entity name in a different context. Therefore, the extraction rate should not be interpreted as the exact frequency of bridge entity representation construction, but rather as a comparative signal: more extraction in one condition versus another indicates more frequent or stronger representations.

OLMo Pretraining Emergence Analysis: Tracking Reasoning Development

The OLMo model family (Groeneveld et al., 2024) releases not only the final model weights but also 557 intermediate training checkpoints (from 1K to 557K pretraining steps) and the exact pretraining sequences that the model learned at each step. This provides a unique opportunity to (a) definitively verify entity co-occurrence (since the full training data is available, not just a proxy corpus) and (b) track when latent multi-hop reasoning emerges during training (Section 6.3, Appendix C.5).

Definitive co-occurrence verification. The authors build an Elasticsearch index over all of OLMo 7B's pretraining sequences and check whether (e1, e2), (e2, e3), and crucially (e1, e3) co-appear in any single training sequence. For the emergence analysis, they only use test queries where e1 and e3 never co-occur in any pretraining sequence across all 557K steps. This is a strictly stronger guarantee than the proxy corpus filtering: it directly verifies that no shortcut from co-occurrence is possible, because the model literally never saw the head and answer entities in the same training example.

Emergence tracking procedure. For each qualifying test query, the authors evaluate the model at every checkpoint on:

The first single-hop query q(r1(e1))
The second single-hop query q(r2(e2))
The multi-hop query q(r2 ◦ r1(e1))
The guessability checks (ablated queries)

They exclude any test case that is guessable or unusable at any of the 557 pretraining steps, ensuring that the entire trajectory is free of shortcut contamination.

The emergence pattern. Among 110 test cases where the model is correct on both single-hop facts at some point during pretraining and never guessable at any point, the model successfully answers the multi-hop query at some point in 13 cases (11.8%). In 12 of these 13 cases, the model begins to correctly answer the multi-hop query only after learning both constituent single-hop facts. Figure 5 illustrates one such case: the model first learns to answer the single-hop queries after repeatedly observing (e1, e2) and (e2, e3) together across multiple training steps, and then—subsequently—begins to correctly answer the multi-hop query.

Interpretation of the emergence evidence. The sequential pattern (single-hop learning → multi-hop emergence) is consistent with genuine latent composition: it suggests the model first learns the individual facts, and only later develops the ability to combine them internally to answer the composed query. If the multi-hop answer were driven by a hidden shortcut or memorized association, we would expect it to appear simultaneously with (or even before) the single-hop facts. The fact that it appears after both single-hop facts are established supports the interpretation that the model is genuinely composing them.

However, the paper is careful about the scope of this finding. The number of success cases (13) is too small for quantitative analysis or statistical claims. The value of the analysis is qualitative: it provides existence proof that even a relatively small model (7B parameters) can develop latent multi-hop reasoning during pretraining, and it establishes a methodology for tracking this emergence in models where full pretraining data is available.

Alignment with Chang et al. (2024). The authors note that the pattern of models learning single-hop facts after repeatedly observing them across multiple training steps "aligns with the finding of Chang et al. (2024) that models learn simple facts by accumulating observations of the fact." This observation about the temporal dynamics of factual knowledge acquisition during pretraining provides context for why latent multi-hop reasoning might emerge only after substantial training: the model needs enough exposure to reliably encode each single-hop fact before it can learn to compose them.

4. Key Insights and Innovations

Innovation 1: Latent Multi-Hop Reasoning Cannot Be Meaningfully Evaluated Without Empirical Shortcut Exclusion—and Prior Evaluations Massively Overestimate It

The paper's most fundamental contribution is not a new dataset but a diagnostic finding: that prior evaluations of latent multi-hop reasoning in LLMs are fundamentally uninterpretable because they fail to exclude shortcuts, and that when these shortcuts are properly controlled, measured latent composability drops by approximately 3×. This is a methodological insight that reframes the entire subfield's evidence base.

What the field assumed before this work. Prior studies on latent multi-hop reasoning (Ofir Press et al., 2023; Yang et al., 2024b; Biran et al., 2024; Li et al., 2024) operated under an implicit assumption: that if you construct multi-hop queries from facts unlikely to appear together naturally, the resulting evaluation measures genuine composition. Ofir Press et al. (2023) designed their Compositional Celebrities dataset around this intuition—combining obscure celebrities' birth years with unrelated events—but never verified against actual pretraining data whether the head and answer entities co-occurred. The assumption was that clever dataset design could outsmart the training distribution. The paper shows this assumption is wrong: 85.30% of Compositional Celebrities test queries contain head-answer entity co-occurrences in Dolma v1.5 alone (Table 2), a figure that rises above 95% for 7 of 17 categories and reaches 100% for three categories. This is a devastating empirical finding: the flagship dataset for evaluating latent multi-hop reasoning is overwhelmingly contaminated by the very shortcuts it was designed to avoid.

Why this changes the landscape. This is not a small refinement of an existing approach—it is a fundamental empirical refutation of a methodology that the field had accepted. The 3× overestimation demonstrated in Figure 4 is not a marginal correction but a qualitative difference: at 8.4% latent composability for the best model on SOCRATES versus approximately 25% on the shortcut-prone equivalent, the question shifts from "how well do models reason latently?" to "do models reason latently at all for most query types?" The finding that country-type queries retain high composability even after shortcut exclusion (~80% for top models, Figure 3a) while year-type queries collapse to ~6% reveals that latent reasoning is not a general capability but a query-type-specific phenomenon—a distinction that was invisible in prior evaluations because the shortcut noise masked the composition signal.

The significance beyond performance numbers. This innovation is primarily epistemological: it establishes that you cannot evaluate latent multi-hop reasoning without empirically grounding your shortcut-exclusion criteria in actual training data statistics. Assumption-based filtering is insufficient because co-occurrence patterns in natural text are not intuitive—entities that seem unrelated (a minor celebrity and a Nobel Prize winner born in the same year) routinely co-appear in documents like Wikipedia year-in-review articles, lists of notable births, and award ceremony coverage. The paper's proxy corpus methodology (using 4.8B documents to approximate co-occurrence) is novel not as an engineering contribution but as a principled response to the inaccessibility of proprietary pretraining data: rather than throwing up hands because we cannot see GPT-4's training data, the paper shows that a large union of public corpora provides a tight enough approximation that additional filtering (via Google Search over ~400B documents) changes measured composability by only 3% relative (Appendix C.3). This validation is the key move that transforms the approach from "we tried our best to filter" to "we can quantify how close our approximation is to the ground truth."

Anchoring evidence. The comparative experiment in Figure 4 and Appendix Figure 10, showing that shortcut-free evaluation yields consistently lower composability across all 41 tested models, combined with the Compositional Celebrities co-occurrence analysis in Table 2, directly supports the claim. The finding is not model-specific—it holds across model families, scales, and training paradigms.

Innovation 2: The Bridge Entity Type Is the Dominant Factor Governing Latent Composability—Not Model Scale or Knowledge Breadth

The paper's second major insight is that latent multi-hop reasoning ability is overwhelmingly determined by the type of bridge entity connecting the two facts, with performance varying from ~80% (country-type) to ~6% (year-type) for the same models on the same evaluation framework (Figure 3a). This finding fundamentally reorients the question from "can models reason latently?" to "for which types of compositional structures do models develop latent reasoning, and why?"

What the field assumed before this work. Prior evaluations treated multi-hop reasoning as a unitary capability—models either could or couldn't compose facts, and the key variables were model scale, training data volume, or architecture. The scaling laws paradigm (Hoffmann et al., 2022) had conditioned the field to expect that capability improvements would be monotonic in compute, and prior multi-hop reasoning work (Ofir Press et al., 2023; Yang et al., 2024b) reported aggregate scores without systematic breakdown by compositional structure. The implicit model was: more parameters → better reasoning across the board.

What the paper shows instead. The bridge entity type produces a ~13× difference in composability (80% vs. 6%) for the same models, while model scale within a family produces only a marginal improvement (e.g., GPT-4o vs. GPT-4o mini differs by 6.7 percentage points in Figure 2b). Furthermore, the paper shows that models exhibiting high composability on country-type queries are the same models that fail on year-type queries—this is not a "some models are good at reasoning, others aren't" story but rather "all models are good at some compositional structures and terrible at others." The normalized slope metric in Figure 3a (0.78 for country-type queries vs. 0.02 for year-type queries) quantifies this: as models learn more single-hop facts, their multi-hop performance improves rapidly for country-type compositions but barely budges for year-type compositions. The rate of improvement with knowledge acquisition is itself bridge-entity-dependent.

Why this matters conceptually. This finding suggests that latent multi-hop reasoning is not a general reasoning capability that emerges uniformly from scale, but rather a structure-specific skill that develops when the training distribution provides the right kind of compositional exposure. The paper speculates (Appendix D.2) that country-related facts may be more frequently learned in composition during pretraining—perhaps because text about countries often bundles multiple facts together (anthems, ISO codes, founding years in the same Wikipedia infobox or introductory paragraph), while year-event facts are distributed across temporally organized documents (year pages, event articles) that rarely connect a specific person's birth year to a specific event in the same training sequence. This speculation, while untested, points toward a mechanistic hypothesis: latent composition emerges when the training data naturally presents fact compositions in close proximity, allowing models to learn the compositional pathway through co-occurrence of the single-hop facts (not the head and answer entities, which are filtered).

Distinction from prior work. Ko et al. (2024) examined performance gaps between different numbers of reasoning hops but treated reasoning as a general capacity. Peng et al. (2024) proved theoretical limitations for high-arity relations in single-layer Transformers but did not connect this to the empirical distribution of capabilities across relation types in pretrained models. The paper's finding bridges theory and empirics: it shows that the theoretical difficulty identified by Peng et al. (2024) (year-type relations having high arity in the sense that many entities map to the same year) manifests in practice as near-zero latent composability, while low-arity bridge types (countries, where fewer entities share the same bridge entity value) support robust composition. This connection between relational arity and empirical composability is a conceptual advance that opens the door to predicting which compositional structures will support latent reasoning without running full evaluations.

Anchoring evidence. Figure 3a (latent composability by bridge entity type) and the full per-type breakdown in Appendix Figure 7 directly demonstrate the dramatic performance variation. Figure 2b shows that model scale effects are marginal by comparison. The finding that model scale improves CoT but not latent composability (Figures 2b vs. 2d) reinforces that latent reasoning is not simply a "weaker version" of explicit reasoning that scale will eventually fix—it is qualitatively different in its dependence on compositional structure.

Innovation 3: Latent and CoT Reasoning Exhibit Fundamentally Different Scaling Behavior, Revealing That They Are Distinct Capabilities Rather Than Points on a Continuum

The paper establishes a sharp dissociation between latent and Chain-of-Thought composability that challenges the intuitive assumption that they represent stronger and weaker versions of the same underlying reasoning process. This dissociation manifests in three ways: the magnitude of the gap, the differential response to model scale, and the differential sensitivity to bridge entity type.

What the field assumed before this work. The default assumption in the reasoning literature—implicit in the design of CoT methods (Kojima and Gu, 2022) and in the interpretation of latent reasoning as "implicit Chain-of-Thought" (Deng et al., 2024)—is that CoT and latent reasoning exist on a spectrum: CoT is what happens when you externalize intermediate steps, and latent reasoning is what happens when you perform similar computations internally. Under this view, a model that can do CoT on a problem has the underlying reasoning capability, and the latent version is just a matter of whether that capability surfaces without explicit intermediate token generation. Latent performance should track CoT performance, perhaps with some degradation due to the difficulty of maintaining state without external memory in the form of generated tokens.

What the paper shows instead. The empirical picture is incompatible with this continuum view:

Magnitude of the gap (Figure 2a vs. 2c): GPT-4o achieves 92.8% CoT composability but only 7.6% latent composability—a gap of over 12×. There are "almost no cases where latent reasoning succeeds but CoT fails" (Appendix Figure 9). This asymmetry is striking: CoT nearly always succeeds when latent reasoning succeeds, but the reverse is not true—latent reasoning fails on the vast majority of cases where CoT succeeds. If they were points on a continuum, you would expect more overlap and a less extreme ratio.
Differential response to model scale (Figure 2b vs. 2d): Larger models and models that know more single-hop facts show "dramatic improvements" in CoT composability but only "marginal" improvements in latent composability. CoT composability effectively scales with model capacity; latent composability barely does. This suggests that scaling pretraining compute (which improves single-hop knowledge and general reasoning) addresses the bottleneck for CoT reasoning but not for latent reasoning—implying that the bottleneck for latent reasoning is something else entirely.
Differential sensitivity to bridge entity type (Figure 3a vs. 3b): CoT composability remains relatively consistent across bridge entity types (high for country, still substantial for year), while latent composability collapses for year-type queries. The bridge entity type that is nearly impossible for latent reasoning (year, ~6%) is quite manageable for CoT reasoning (~30–40% composability for top models). This suggests that CoT reasoning can compensate for structural properties (like high relational arity) that are catastrophic for latent reasoning.

Why this matters conceptually. This dissociation reframes the relationship between latent and explicit reasoning from a spectrum to a qualitative difference in mechanism. The paper speculates (Appendix D.3) that the key factor is the explicit generation of the bridge entity: when CoT generates "Scarlett Johansson was born in 1984," it ensures a clear, early, contextually grounded representation of the bridge entity that facilitates retrieval of the second fact. In latent reasoning, the model must construct this representation internally from the descriptive mention ("the year Scarlett Johansson was born") and use it to retrieve the second fact—all within the forward pass, without the opportunity to "see" its own intermediate output and condition subsequent computation on it. The fact that merely instructing models to think step-by-step internally—without generating tokens—does not improve performance (Claude 3.5 Sonnet achieves only 6.1% latent composability even with explicit hints to identify and use the bridge entity information, per Appendix D.3) supports the view that token generation itself is not just an externalization of internal computation but plays a causal role in enabling the computation. The generated tokens create a persistent, attendable representation that the model can use as working memory in subsequent steps—something that recurrent computation within the same forward pass may not replicate.

The training-inference gap as a diagnostic. The paper also finds that 96.0% of CoT failures for Claude 3.5 Sonnet stem from incorrect bridge entity generation (Appendix D.3)—the model retrieves the wrong first-hop fact. This means that CoT's advantage is not in better second-hop retrieval given the correct bridge entity, but in higher success at the first hop itself (perhaps because the CoT format encourages more careful retrieval). This decomposition—CoT helps primarily with first-hop accuracy, not composition—is a novel diagnostic that was not available from aggregate performance numbers alone.

Anchoring evidence. The CoT vs. latent composability comparison (Figures 2a vs. 2c, 2b vs. 2d), the bridge entity type breakdown for both modes (Figures 3a vs. 3b), the near-zero latent-success-with-CoT-failure cases (Appendix Figure 9), and the bridge entity error analysis (Appendix D.3) collectively support the claim that these are distinct capabilities rather than points on a spectrum.

Innovation 4: The Co-occurrence Filter Itself Reveals That Shortcut-Free Multi-Hop Queries Are Rare—and Their Distribution Is Inherently Skewed

A subtle but significant contribution is that the dataset construction process itself—specifically the co-occurrence filter—generates knowledge about the structure of natural text that is valuable independent of the model evaluation results. The dramatic reduction from ~100K candidate fact pairs to ~32K after co-occurrence filtering (a ~68% elimination rate) and the resulting distributional skew toward year-type bridge entities (Table 1) are not just construction details—they are empirical findings about the prevalence of entity co-occurrence in natural language and its dependence on compositional structure.

What this reveals about text. The fact that ~68% of plausible multi-hop fact compositions have head and answer entities that co-occur somewhere in 4.8B documents means that entity co-occurrence is not an edge case but the norm for most relation types. Country-type compositions are especially likely to co-occur—most test cases with country bridge entities were eliminated because the head entity (a person or university) and answer entity (a national symbol like an anthem or ISO code) appear together in documents like Wikipedia country pages, encyclopedic entries, or travel guides. Year-type compositions survive filtering more often because the head entity (a person born in year X) and the answer entity (a Nobel Prize winner in year X, or an Olympic host city in year X) are connected through the year rather than directly—they may appear on the same "1984" Wikipedia page but rarely in the same sentence or even the same section, and may not co-occur within the document boundaries that define training sequences in most LLM pretraining pipelines (Zhao et al., 2024).

Why this matters for dataset construction more broadly. This finding establishes that you cannot construct shortcut-free multi-hop datasets by controlling only the semantic relationships between facts—you must control for document-level co-occurrence, which is a function of how text is organized (by topic, by entity, by time) rather than how facts are logically related. The paper's methodology of checking against actual corpora rather than relying on intuition about what "should" co-occur provides a template for future dataset construction efforts that aim to control for training data contamination. The finding that different relation types have systematically different co-occurrence rates implies that any evaluation of multi-hop reasoning must report per-relation-type results—aggregate scores are dominated by the relation types that survived filtering, which may not be representative of the capability being measured.

Anchoring evidence. The 68% elimination rate is documented in the dataset construction pipeline (Section 4.1, Step 3 and Appendix A.2). The distributional skew is visible in Table 1 (6,975 year-type cases vs. 166 country-type cases). The Compositional Celebrities analysis in Table 2 provides external validation that the problem is pervasive in existing datasets.

5. Experimental Analysis

Evaluation Methodology

Dataset. SOCRATES (SHORTCUT-FREE LATENT REASONING) contains 7,232 test cases of 17 relation composition types connected by 4 bridge entity types (country, city, university, year), drawn from Wikidata and filtered using document-level co-occurrence statistics from a 4.8B-document proxy corpus (Dolma v1.5/v1.7, Tulu v2, OSCAR, C4, OpenWebText). The test set is used in its entirety for evaluation; there is no train/dev/test split because the paper evaluates pretrained models without fine-tuning. Each test case consists of three queries: two single-hop queries q(r1(e1)) and q(r2(e2)), plus one multi-hop query q(r2 ∘ r1(e1)), each with associated entity alias sets for exact-match scoring.
Base model(s). 41 LLMs from 9 model families are evaluated: Claude 3.5 Sonnet, GPT-4o, GPT-4o mini, Gemini 1.5 Pro, Gemini 1.5 Flash (proprietary), plus open-source models from Mistral (7B to 123B), Mixtral (8×7B), Qwen 2 and 2.5 (7B to 72B), Yi 1.5 (6B to 34B), Gemma 1 and 2 (2B to 9B), and OLMo (7B), spanning both pretrained and instruction-tuned variants. Models were chosen to represent "the capabilities of many contemporary LLMs" (as stated in the paper), covering a range of scales, training paradigms, and access levels. All models are evaluated in a zero-shot setting without fine-tuning, since the target question concerns latent reasoning abilities that naturally emerge during pretraining.
Metrics. The primary metric is latent composability: the fraction of test cases where the model correctly answers both single-hop queries and the multi-hop query, excluding cases that are guessable (model succeeds on ablated queries where head entity information is removed) or unusable (model generates the bridge entity before the answer or enumerates multiple-choice options). Correctness is determined by normalized exact match—the model's completion, after lowercasing, accent removal, article removal, abbreviation space removal, and punctuation-to-space replacement, must contain any alias from the answer set respecting word boundaries. For model comparisons, comparative latent composability is computed using the intersection of test cases where all compared models know both single-hop facts and no model exhibits guessable or unusable behavior. CoT composability is measured using the same denominator logic but with a CoT-triggering instruction that asks for explicit step-by-step explanation before the answer. Additionally, normalized slope is reported in Figures 3a and 3b: the slope of the composability-vs-number-of-known-facts curve, normalized by the range of the y-axis, measuring how quickly composability improves as models learn more single-hop facts.
Baselines. The paper does not use traditional baselines (since it is not proposing a new method that needs to outperform existing approaches). Instead, it establishes evaluation conditions as comparators: (1) shortcut-prone data + shortcut-prone evaluation: a dataset constructed from the same Wikidata distribution as SOCRATES but without co-occurrence filtering or relation-specific heuristics, evaluated without guessability or unusability exclusions (Figure 4, Appendix Figure 10). (2) Compositional Celebrities (Ofir Press et al., 2023): the prior dataset is analyzed for co-occurrence contamination rather than used as a performance baseline, with co-occurrence rates reported per relation type (Table 2). (3) CoT reasoning: the same models on the same SOCRATES queries but with explicit Chain-of-Thought instructions, serving as an upper bound on what models can achieve when allowed to reason explicitly (Figures 2c, 2d, 3b). (4) Internal think-step-by-step: an instruction that tells models to think step-by-step internally without generating tokens (Appendix D.3), serving as a test of whether the computation underlying CoT can be performed latently.
Generation budget / compute accounting. The paper does not use a generation budget in the traditional sense because all evaluations use a single greedy decoding pass per query (temperature = 0, or the default decoding parameters specified in generation_config.json for HuggingFace models). There is no sampling, beam search, or ensemble—each model produces exactly one completion per query. Compute is measured indirectly through model scale comparisons (Figures 2b, 2d) by grouping models within the same family at different parameter counts. The FLOPs-matched pretraining-vs-inference comparison that appears in the earlier example (Section 7 of the referenced paper) is not part of this paper's experimental design, so there is no inference compute budget to account for.
Cross-validation / statistical protocol. There is no cross-validation because there is no training or hyperparameter selection—all models are evaluated zero-shot. The paper does not report confidence intervals, statistical significance tests, or error bars. The two-fold cross-validation described in the earlier example paper is not used here because SOCRATES involves no strategy selection or hyperparameter optimization. For the comparative latent composability metric, the paper ensures fair comparison by using the exact same denominator (the intersection of test cases satisfying conditions for all compared models), rather than computing composability independently for each model and comparing the resulting percentages. The primary statistical concern addressed is denominator size: for bridge-entity-type breakdowns (Figures 3a, 3b, and Appendix Figures 7, 8), results are only plotted when the number of cases where the model knows both single-hop facts (the denominator) is sufficiently large, though no explicit threshold is stated. The Google Search validation experiment (Appendix C.3) only reports results "when the denominator used to calculate the composability is greater or equal to 30" (Appendix Figure 10 caption), establishing a minimum cell size for reported comparisons. For the Patchscopes experiment (Figure 6, Appendix Figure 11), results are shown only for country and year-type bridge entities because other types have "an insufficient number of such cases" where both single-hop facts are known.

Main Quantitative Results

Aggregate Latent Composability Across All Query Types

The headline finding is that overall latent composability is low across all tested models, but this aggregate number masks enormous variation across query types. As shown in Figure 2a, the best-performing models—Claude 3.5 Sonnet and GPT-4o—achieve latent composability of only 8.4% and 7.6% respectively on the full SOCRATES dataset (434 and 438 successful multi-hop cases, out of the denominator of cases where both single-hop queries are answered correctly and cases are neither guessable nor unusable). Most other models cluster below 5%, with many smaller or pretrained-only models showing near-zero composability.

The absolute number of successful cases (434 for Claude 3.5 Sonnet, 438 for GPT-4o) is described as "meaningful," but the percentage is low because the denominator is large—dominated by year-type bridge entity queries (6,975 of 7,232 total cases), for which composability is very low for all models. This is a critical calibration point: if you only look at aggregate metrics, you would conclude that LLMs barely perform latent multi-hop reasoning at all. The paper's central argument is that this aggregate is misleading because it conflates query types with dramatically different composability rates.

The shortcut-prone comparison in Figure 4 (and Appendix Figure 10) quantifies the impact of the paper's methodological choices: latent composability measured with shortcut-free data and evaluation is approximately 3× lower than when measured with shortcut-prone data and evaluation (the exact ratio varies by model, but Figure 4 shows the shortcut-prone condition averaging roughly 3× the shortcut-free condition across models). This gap is consistent across all 41 models (Appendix Figure 10), with no model showing comparable composability under both conditions. The paper also reports intermediate conditions: shortcut-prone data with shortcut-free evaluation, and shortcut-free data with shortcut-prone evaluation, both of which fall between the two extremes—confirming that both the dataset construction (co-occurrence filtering, heuristic exclusions) and the evaluation procedure (guessability checks, unusability exclusions) independently contribute to lowering measured composability. Specifically, using shortcut-free data alone (without guessability checks) overestimates composability relative to the full procedure, and using shortcut-free evaluation alone (on shortcut-prone data) also overestimates composability.

Latent Composability by Bridge Entity Type

The paper's most striking result is the dramatic variation in latent composability across bridge entity types, shown in Figure 3a (country and year) and Appendix Figure 7 (all four types). The key comparison:

Country-type bridge entities (166 test cases): Claude 3.5 Sonnet and GPT-4o achieve 82.6% and 84.5% latent composability, respectively. The normalized slope for this subset is 0.78, indicating that as models learn more single-hop facts involving countries, their multi-hop success rate improves rapidly and substantially (Figure 3a, left panel). This is the paper's strongest positive result—evidence that, for this specific compositional structure, state-of-the-art models genuinely compose facts latently without exploiting shortcuts.
Year-type bridge entities (6,975 test cases): Claude 3.5 Sonnet and GPT-4o achieve only 6.7% and 5.7% latent composability, respectively. The normalized slope is 0.02 (Figure 3a, right panel), meaning that even as models learn more single-hop facts involving years, their multi-hop success barely improves—the curve is essentially flat at the bottom of the plot. This near-zero slope is a key finding: it suggests that for year-type compositions, the bottleneck is not insufficient single-hop knowledge (since models with more known facts still cannot compose them) but rather a fundamental limitation in how models internally represent or utilize year-type bridge entities for retrieval.
City-type bridge entities (33 test cases): Appendix Figure 7b shows a normalized slope of 0.27—intermediate between country and year, with top models roughly in the 20–40% composability range. However, the denominator is small (maximum ~20 cases where both single-hop facts are known by any model), making these estimates noisy.
University-type bridge entities (58 test cases): Appendix Figure 7c shows a normalized slope of 0.05—close to year-type in its flatness, with composability generally below 10%. Again, small denominators limit reliability.

The normalized slope metric provides a bridge-entity-type comparison that is independent of the absolute number of test cases or the overall knowledge coverage. A slope near 1.0 (country) means that gaining single-hop knowledge translates efficiently into multi-hop success; a slope near 0.0 (year) means that even perfect single-hop knowledge would not enable multi-hop composition. The paper interprets this as evidence that something about the year-type compositional structure is fundamentally harder for latent reasoning—not just that models know fewer year-related facts.

The CoT composability by bridge entity type (Figure 3b, Appendix Figure 8) provides a critical contrast. For country-type queries, CoT composability shows a normalized slope of 0.67—similar to latent composability's 0.78, suggesting that explicit reasoning doesn't add much beyond what latent reasoning already achieves for this type. For year-type queries, however, CoT composability shows a normalized slope of 0.70—dramatically higher than latent composability's 0.02, and similar to the slope for country-type queries under both modes. This means CoT reasoning largely eliminates the bridge-entity-type disparity: when models can explicitly generate the bridge entity, year-type compositions become almost as tractable as country-type compositions (Figure 3b, right panel, shows many models achieving substantial composability on year-type queries under CoT, in stark contrast to the near-zero latent composability on the same subset).

Model Scale and Knowledge Effects

Figure 2b shows comparative latent composability across model scales within the same family. The consistent pattern is that larger models achieve higher latent composability than smaller models from the same family, but the absolute improvement is small. Specific comparisons:

GPT-4o vs. GPT-4o mini: latent composability gap of 6.7 percentage points (118 more successful cases for GPT-4o). This is the largest absolute gap among the paired comparisons, which is notable given that GPT-4o and GPT-4o mini may differ substantially in parameter count (the exact sizes are not disclosed for proprietary models).
Gemini 1.5 Pro vs. Gemini 1.5 Flash: gap of 2.4 percentage points (31 more cases).
Mistral family: Mistral Large Instruct (123B), Small Instruct (22B), and Nemo Instruct (12B) show a consistent ordering with Large outperforming Small outperforming Nemo, though the gaps are not individually quantified in the text.
Qwen 2.5 family: 72B Instruct vs. 32B Instruct shows a small positive gap, visible in Figure 2b as a rightward shift in the curve.

The key interpretive point is that these improvements are marginal in both absolute and relative terms compared to the bridge-entity-type effect. Moving from a 7B to a 72B model within the Qwen 2.5 family improves latent composability by a few percentage points at most; moving from year-type to country-type bridge entities improves composability by ~75 percentage points for the same model.

In contrast, CoT composability improves dramatically with model scale (Figure 2d). Models that know more single-hop facts and larger models both show substantial rightward and upward shifts in the CoT composability curve—the relationship between knowledge coverage and multi-hop success is much steeper under CoT than under latent reasoning. This divergence is one of the paper's central empirical findings: scaling helps explicit reasoning much more than latent reasoning.

CoT vs. Latent Composability Comparison

Figures 2a and 2c, placed side by side, reveal the magnitude of the latent-CoT gap. GPT-4o achieves 92.8% CoT composability versus 7.6% latent composability—a factor of more than 12×. The gap is consistent across all models: Claude 3.5 Sonnet shows a similar disparity, and even smaller models that achieve non-trivial CoT composability (e.g., Qwen 2.5 72B Instruct) show near-zero latent composability on the same denominator.

Appendix Figure 9 decomposes the relationship further by categorizing test cases into four groups: CoT success + latent success, CoT success + latent failure, CoT failure + latent success, and CoT failure + latent failure (all conditional on knowing both single-hop facts and excluding guessable/unusable cases). The key finding: there are almost no cases where latent reasoning succeeds but CoT fails. The green bars (CoT failure + latent success) are essentially invisible for all models with sufficient data. This asymmetry means that latent reasoning success is a nearly perfect subset of CoT reasoning success—if a model cannot do it with explicit step-by-step generation, it certainly cannot do it latently. The reverse does not hold: the vast majority of cases where CoT succeeds (large blue "CoT success + latent failure" bars) are cases where latent reasoning fails.

The bridge-entity-type breakdown of this comparison (Figures 3a vs. 3b) reveals that the gap is not uniform: for country-type queries, latent and CoT composability are relatively close (both in the 80–90% range for top models), while for year-type queries, CoT composability is 30–50% for many models versus latent composability of 5–7%. This means the latent-CoT gap is almost entirely driven by the year-type (and to a lesser extent university-type) subsets—exactly the query types where latent reasoning fails.

Shortcut-Prone Comparative Experiment

Figure 4 and Appendix Figure 10 provide the controlled comparison that quantifies the impact of the paper's methodological framework. A dataset was constructed with "almost exactly the same distribution of the relation composition types (and thus the bridge entity types) of SOCRATES, but without applying any measure to remove potential shortcuts such as the entity co-occurrence-based filtering or relation-specific heuristics." Four evaluation conditions are compared:

Shortcut-prone data & shortcut-prone evaluation: The least rigorous condition—only checks whether both single-hop facts are known, without guessability or unusability exclusions.
Shortcut-prone data & shortcut-free evaluation: Uses the SOCRATES evaluation procedure (guessability checks, unusability exclusion) but on the unfiltered data.
Shortcut-free data & shortcut-prone evaluation: Uses SOCRATES data but only checks single-hop knowledge.
Shortcut-free data & shortcut-free evaluation: The full SOCRATES pipeline.

Figure 4 shows the average latent composability across models for each condition (models shown individually in Appendix Figure 10). The full shortcut-free condition yields composability roughly one-third of the full shortcut-prone condition. The intermediate conditions (2 and 3) fall between the extremes, confirming that both the dataset-level filtering and the evaluation-level exclusions independently contribute to the reduction. This is an important validation: it shows the shortcut problem cannot be solved by either better data or better evaluation alone—both are necessary. Appendix Figure 10 demonstrates this holds consistently across all 41 models—there is no model for which the shortcut-prone evaluation does not substantially overestimate composability relative to the shortcut-free evaluation.

The Compositional Celebrities analysis in Table 2 provides external validation of the co-occurrence problem. Using the WIMBD API to check head-answer entity co-occurrence in Dolma v1.5:

85.30% of test queries across all categories show head-answer entity co-occurrence (7,415 out of 8,693 total queries).
Three categories are completely unusable: person-country-capital (100%, 468/468), person-country-roundedlat (100%, 468/468), and person-country-roundedlng (100%, 468/468).
Seven categories exceed 95% co-occurrence rates (the three above plus person-country-callingcode, person-country-ccn3, person-country-spacommonname, and person-country-tld).
Only one category falls below 50%: person-country-urdcommonname at 20.51%, likely because Urdu common names for countries are rare in English-language corpora.
The paper notes these are conservative estimates: only Dolma v1.5 was used, not all aliases were checked, and additional corpora would only increase co-occurrence rates.

Taken together, these results establish that the Compositional Celebrities dataset—the primary prior benchmark for latent multi-hop reasoning—is overwhelmingly contaminated by subject-object shortcuts, making its results uninterpretable for the question the current paper addresses. This is not a small methodological quibble but a fundamental empirical finding that calls into question the conclusions of prior work.

Patchscopes Representation Analysis

Figure 6 (and the expanded Figure 11 in the appendix) shows the Patchscopes extraction rate heatmaps for Mistral 7B v0.3, comparing queries with country-type bridge entities (left column) to those with year-type bridge entities (right column), and comparing extraction of the bridge entity e2 (top row) to extraction of the answer entity e3 (bottom row, in Figure 11), at two positions: the last token of the descriptive mention of the bridge entity, and the last token of the full multi-hop query.

The central finding: bridge entity representations are extracted substantially more often for country-type queries than for year-type queries. For country-type queries, the extraction rate for e2 at the end of the descriptive mention reaches approximately 0.4–0.5 in the diagonal band (where source and target layers match in the middle-to-late range, roughly layers 15–25), visualized as a bright region in the top-left heatmap of Figure 6. For year-type queries, the corresponding heatmap (top-right) is markedly colder, with maximum extraction rates around 0.1–0.2, concentrated in a narrower band of layers.

The e2 extraction at the end of the full query (Figure 11, second row) shows a similar pattern: country-type queries produce extractable bridge entity representations in late source layers (around layers 20–28) when patched into mid-to-late target layers, while year-type queries show much weaker extraction.

The e3 extraction (Figure 11, bottom rows) is generally weaker than e2 extraction for both types, which is expected—the answer entity is further downstream from the descriptive mention and its representation may be distributed differently. The pattern is still consistent: country-type queries show more extraction than year-type queries.

The paper interprets these results as evidence that the behavioral difference in latent composability (80% for country, 6% for year) is reflected in the model's internal representations: when processing queries with country-type bridge entities, the model more reliably constructs a latent representation of the bridge entity from the descriptive mention, which then enables retrieval of the second fact and, ultimately, the answer. For year-type queries, this bridge entity representation is constructed less frequently or less strongly, causing the composition to fail.

The paper is careful to note that the extraction rate is "a lower bound of how often the latent representation of the entity is constructed"—a representation might encode the bridge entity in a way that supports downstream computation without being cleanly decodable as the entity name in the Patchscopes target prompt. The key evidence is therefore the comparative pattern (country > year) rather than the absolute extraction rates.

Emergence of Latent Multi-Hop Reasoning During Pretraining (OLMo Analysis)

The OLMo 7B intermediate checkpoint analysis (Section 6.3, Appendix C.5) provides the paper's only causal evidence that latent multi-hop reasoning can emerge from pretraining without any possibility of shortcut exploitation. Among 110 test cases where OLMo 7B correctly answers both single-hop queries at some point during pretraining and is never guessable at any checkpoint:

13 cases (11.8%) show successful multi-hop reasoning at some checkpoint.
In 12 of these 13 cases, the model begins to correctly answer the multi-hop query only after learning both constituent single-hop facts. The multi-hop success emerges subsequent to single-hop learning, not simultaneously or before.
The remaining 1 case (where multi-hop success appears before both single-hop facts are known) might reflect a different dynamic or a measurement artifact—the paper does not elaborate.

Figure 5 illustrates one representative successful case: the model first learns to correctly answer the single-hop queries after repeatedly observing (e1, e2) and (e2, e3) across multiple pretraining steps (visible as the "first single-hop query correctly answered" and "second single-hop query correctly answered" indicators turning from False to True early in training). Only after both single-hop facts are consistently known does the model begin to correctly answer the multi-hop query (the "multi-hop query correctly answered" indicator turning True later in training, around step 400K+). Critically, the indicators for e1-e3 co-occurrence remain False throughout all 557K pretraining steps—this specific head-answer entity pair never appears together in any training sequence, ruling out shortcut-based explanations.

The paper acknowledges the limitations of this analysis: the number of success cases (13) is "too small for quantitative analysis." Its value is as an existence proof: even a relatively small 7B-parameter model can develop some genuine latent multi-hop reasoning ability during pretraining, and the sequential emergence pattern (single-hop first, multi-hop later) is consistent with a compositional mechanism rather than memorized associations.

Ablation Studies and Robustness Checks

Google Search co-occurrence validation (Appendix C.3): For the country-type bridge entity subset—where latent composability is highest and any residual co-occurrence would be most concerning from a shortcut interpretation—the paper applies an additional Google Search filter that removes any test case where the head and answer entities appear together in any of approximately 400 billion indexed documents. The average relative drop in latent composability across the five models with sufficient denominator size is 0.03 (3%), computed as E[(c - c')/c] where c is the original composability and c' is the composability after the Google filter. This minimal drop validates that the 4.8B-document proxy corpus already captures most web-wide co-occurrences—the additional filtering barely changes the measured composability.

Unusability exclusion types (Appendix B.1): Two distinct types are identified and removed. The multiple-choice enumeration pattern (model outputs "1. Option A 2. Option B") is observed most frequently with pretrained Qwen2 models, likely due to training on multiple-choice QA corpora. This is detected and excluded from both single-hop and multi-hop queries. The bridge entity generation pattern (model generates e2 before e3) is checked only for multi-hop queries where the exact match score is 1, by scanning the completion for any alias of e2 appearing before the earliest alias of e3. The paper does not report the frequency of either exclusion type separately.

Single-hop quality assurance (Appendix A.4): Cases where all evaluated open-source LLMs fail to correctly answer either single-hop query are discarded from SOCRATES. This serves as a data quality filter: systematic failure across all models suggests either noise in the Wikidata alias set (where the correct answer is not in the answer options) or facts that are too obscure to be in any model's parametric knowledge. The paper does not report how many cases were removed at this step.

Relation-specific heuristic filtering (Appendix A.1, Table 3): Before co-occurrence filtering, the paper applies heuristics to remove cases where e1 and e3 might be connected through alternative single-hop relations (e.g., excluding person-birthyear-eventcountry cases where the event country equals the person's birth country). The paper does not report an ablation where these heuristics are removed, so their independent contribution to the final dataset's shortcut-free status cannot be isolated. However, these heuristics are described as part of Step 1 (fact pair selection) and operate on logical relationships between entities, making them complementary to the co-occurrence-based filtering in Step 3.

Bridge entity inferrability filtering (Appendix A.3): For university-locationcountry and person-birthcountry relations, test cases where GPT-3.5 Turbo or Claude 3 Haiku can correctly guess the bridge entity solely from the head entity name are excluded. This removes cases like university-locationcountry(University of Washington) where the country is inferrable from the institution name. The paper only reports this as a dataset construction step, not as a quantified ablation. The effectiveness of this filter is attested by the continued high latent composability on country-type queries (82.6–84.5% for top models)—these successes are on cases like university-locationcountry(The International Graduate School of English) = South Korea, where the bridge entity cannot be guessed from the head entity's surface form.

Internal think-step-by-step instruction (Appendix D.3): To test whether the computational benefit of CoT can be achieved without explicit token generation, the paper evaluates models with an instruction to "Think step-by-step, but do it only internally and do not explain it in the answer," plus an explicit hint about the bridge entity. Claude 3.5 Sonnet's latent composability under this instruction is 6.1%, similar to its standard latent composability of 8.4% and far below its CoT composability. This supports the interpretation that explicit token generation plays a causal role in enabling the reasoning—it is not merely an externalization of an internal computation that could be performed silently.

CoT error decomposition (Appendix D.3): For Claude 3.5 Sonnet, 96.0% of CoT failures on SOCRATES stem from incorrect bridge entity generation (the model retrieves the wrong first-hop fact). This means CoT's advantage over latent reasoning is primarily in first-hop retrieval accuracy, not second-hop composition given the correct bridge entity. This decomposition is a diagnostic finding that was not hypothesized a priori and emerged from the data.

Co-occurrence rates in Compositional Celebrities (Table 2): The per-category breakdown of head-answer entity co-occurrence in Dolma v1.5 reveals that some relation types are far more contaminated than others. person-country-capital, person-country-roundedlat, and person-country-roundedlng all show 100% co-occurrence rates—every single test case in these categories has head and answer entities that appear together in at least one Dolma document. person-year-uspresident shows 98.45% co-occurrence. Only person-country-urdcommonname (20.51%) and person-country-estcommonname (64.32%) fall below 70%, likely because they involve non-English country name representations that are rare in English-dominated corpora. This analysis validates that the shortcut problem is not a minor edge case but a pervasive property of naturally constructed multi-hop query datasets.

Critical Assessment

Does the paper demonstrate that LLMs perform latent multi-hop reasoning without exploiting shortcuts?

Yes, but only for specific query types. The country-type bridge entity results (82.6–84.5% latent composability for top models, Figure 3a) provide convincing evidence of genuine latent multi-hop reasoning. The combination of safeguards—(1) co-occurrence filtering across 4.8B documents, (2) Google Search validation showing only a 3% relative drop with additional filtering, (3) bridge entity inferrability filtering using LLM baselines, (4) relation-specific heuristics excluding alternative single-hop connections, (5) guessability checks via ablated queries, and (6) unusability exclusions for explicit bridge entity generation—makes it extremely unlikely that the high composability on country-type queries is attributable to shortcuts. The Patchscopes analysis (Figure 6) provides convergent mechanistic evidence: bridge entity representations are more frequently constructed for query types where behavioral composability is higher.

However, this reasoning ability is not general. For year-type queries (which constitute 6,975 of 7,232 test cases, or 96.5% of SOCRATES), latent composability is approximately 6-7%—barely above what might be expected from random chance or residual uncaught shortcuts. The paper demonstrates that models largely cannot perform latent multi-hop reasoning when the bridge entity is a year. The claim "LLMs demonstrate promising latent multi-hop reasoning abilities" (from the abstract) must therefore be heavily qualified: this holds for country-type bridge entities specifically, and the paper does not establish how generalizable this is beyond the specific relation types included in SOCRATES (which are themselves a curated subset from Wikidata).

Does the paper demonstrate that shortcut-free evaluation is important?

Yes, convincingly. The comparative experiment (Figure 4, Appendix Figure 10) showing approximately 3× overestimation with shortcut-prone evaluation is clean and well-controlled: it uses the same models, the same relation composition distribution, and varies only the filtering and evaluation procedure. The Compositional Celebrities analysis (Table 2) showing 85.30% co-occurrence contamination provides external evidence that the problem is not specific to the paper's dataset construction but affects existing benchmarks. The finding that both data-level and evaluation-level controls independently reduce measured composability (the intermediate conditions in Figures 4 and 10) strengthens the claim that comprehensive shortcut exclusion requires attention to both.

One limitation: the shortcut-prone dataset is described as having "almost exactly the same distribution of the relation composition types" as SOCRATES, but no further characterization is provided. It is possible that the specific facts differ in ways that affect difficulty beyond shortcut presence—for instance, the filtered-out facts might be more obscure or involve rarer entities than the surviving facts. If the shortcut-prone dataset contains systematically "easier" facts (more famous entities, more frequent relations), some of the composability gap might reflect genuine difficulty differences rather than pure shortcut effects. A stronger design would have been to start from the exact same fact pool and randomly disable filters, but this may have been impractical given how the filters interact.

Does the paper demonstrate that latent composability varies across bridge entity types?

Yes, this is the strongest empirical finding in the paper. The gap between country-type (~80%) and year-type (~6%) composability for the same models on the same evaluation framework is large, consistent across models, and corroborated by both behavioral and representational evidence (Patchscopes). The normalized slope metric (0.78 vs. 0.02) provides a bridge-entity-type comparison that controls for differences in overall knowledge coverage.

However, the interpretation of why this variation exists is speculative. The paper suggests (Appendix D.2) that country-related facts may be "more frequently learned in composition during pretraining," but provides no direct evidence for this—no analysis of co-occurrence patterns of the single-hop facts themselves in training corpora, no measurement of how often country-fact tuples appear in close proximity versus year-fact tuples. The Patchscopes analysis shows that bridge entity representations are constructed more often for country-type queries, but not why—it doesn't reveal whether this is due to training data composition patterns, architectural properties, or other factors. The connection to Peng et al. (2024)'s theoretical result about high-arity relations is intriguing but remains correlational.

Does the paper demonstrate that latent and CoT reasoning are distinct capabilities?

Yes, the evidence for a qualitative distinction is strong. Three dissociations support this: (1) the magnitude of the latent-CoT gap (7.6% vs. 92.8% for GPT-4o, Figure 2a vs. 2c), (2) the differential response to model scale (marginal improvement for latent, dramatic for CoT, Figures 2b vs. 2d), and (3) the differential sensitivity to bridge entity type (year-type composability collapses latently but remains robust under CoT, Figures 3a vs. 3b). The near-zero "CoT failure + latent success" cases (Appendix Figure 9) show that latent success is a strict subset of CoT success, not an independent capability. The internal think-step-by-step ablation (6.1% composability, similar to standard latent) suggests that token generation itself plays a causal role beyond simply recording intermediate state.

A missing experiment: it would have been informative to test whether latent composability improves when the model is allowed to generate only the bridge entity (without full CoT), to isolate whether the key bottleneck is first-hop retrieval (as the 96% CoT failure analysis suggests) or second-hop retrieval given the bridge entity representation. The Patchscopes analysis partially addresses this by probing for bridge entity representations, but a behavioral experiment where models are forced to generate the bridge entity and then answer latently would provide complementary evidence.

Does the paper demonstrate emergence of latent multi-hop reasoning during pretraining?

Partially, with important caveats. The OLMo analysis (13 success cases out of 110 qualifying cases, with 12 showing the expected single-hop-then-multi-hop emergence pattern) provides existence proof that even a 7B model can develop genuine latent multi-hop reasoning through pretraining. The guarantee that head and answer entities never co-occur in any training sequence (possible because OLMo's full pretraining data is available) makes this the cleanest evidence in the paper for shortcut-free reasoning.

However, the small number of success cases (13) severely limits the generalizability of this analysis. It demonstrates possibility but not prevalence or reliability. The sequential emergence pattern (single-hop learning first, multi-hop later) is consistent with compositional mechanisms but could also be consistent with other explanations—for instance, the model might need a certain density of related facts in its training before it can form the compositional association, and the sequential pattern reflects the order in which facts are encountered. Without causal interventions (e.g., manipulating training data to control when single-hop facts are learned and testing the effect on multi-hop emergence), the temporal correlation cannot be definitively interpreted as evidence of compositional learning.

Additional weaknesses and missing experiments

Single-model mechanism analysis. The Patchscopes experiments use only Mistral 7B v0.3. While this choice is justified (open-source, appropriate scale, pretrained rather than instruction-tuned), it means we cannot assess whether the representational patterns observed (bridge entity extraction rates correlating with composability) generalize across model families, scales, or training paradigms. The top-performing models on latent composability (Claude 3.5 Sonnet, GPT-4o) cannot be analyzed with Patchscopes because their internal representations are not accessible.

No statistical significance reporting. The paper does not report confidence intervals, standard errors, or statistical tests for any of the composability comparisons. For the bridge-entity-type breakdowns where denominators are small (city: ~20 cases max for any model, university: similar), the composability estimates could have substantial variance that is not communicated. The normalized slope metric partially addresses denominator concerns by measuring trends rather than point estimates, but the slopes themselves are point estimates without uncertainty quantification.

The denominator problem for model comparisons. The comparative latent composability metric uses the intersection of cases where all compared models know both single-hop facts and are not guessable/unusable. This intersection can be quite small, especially when comparing models with very different knowledge coverage (e.g., a 2B model versus a proprietary model). The paper does not report denominator sizes for each comparison in Figures 2b and 2d, making it difficult to assess the reliability of the observed improvements with scale. A model pair with a denominator of 10 cases showing a 5-percentage-point gap means one additional correct answer—hardly a robust finding.

No analysis of instruction-tuning vs. pretraining effects on latent composability. The paper evaluates both pretrained and instruction-tuned models, and Figure 2a shows both types across the composability spectrum, but there is no systematic comparison or analysis of whether instruction-tuning helps or hurts latent reasoning. Some pretrained models (e.g., Qwen 2.5 72B) appear competitive with instruction-tuned counterparts, while others show near-zero composability. This could reflect differences in base model quality, training data composition, or instruction-tuning effects—the paper does not disentangle these.

The temporal stability criterion excludes potentially informative relation types. The paper excludes relations "subject to frequent change over time (organization-CEO or person-spouse)" to ensure fair comparison across models with different knowledge cutoff dates (Appendix A.1). While this is a reasonable fairness consideration, it also removes relation types where latent multi-hop reasoning might be most practically useful—updating knowledge about a CEO and having that propagate to multi-hop queries about the company's leadership would be a compelling test case for the knowledge editing motivation discussed in the introduction.

No analysis of whether simplified query formulations change results. The descriptive-mention format (e.g., "In the year Scarlett Johansson was born") is a specific linguistic construction that may be harder for models to parse than more explicit formulations ("Scarlett Johansson was born in 1984. In that year, the Summer Olympics..."). Testing alternative phrasings would help distinguish whether the low year-type composability is due to difficulty composing facts per se, or difficulty parsing the descriptive mention into a usable bridge entity representation. The Patchscopes result showing weaker extraction for year-type queries is partially informative here, but a behavioral experiment varying the linguistic framing would be complementary.

The Patchscopes extraction rate is a lower bound and its interpretation requires care. As the paper acknowledges, a representation might encode the bridge entity usefully for downstream computation without being cleanly decodable as the entity string. The difference in extraction rates between country and year types (Figure 6) could therefore reflect differences in decodability rather than differences in encoding. Years are tokens that appear in many contexts (not just as bridge entities), which might make their representations less distinct and harder to decode through activation patching, even if they are functionally useful for the model's internal computation. The paper does not discuss this confound.

Summary of claim-evidence alignment

The paper's central claims and their evidentiary support:

"Shortcut-free evaluation is critical because prior datasets overestimate latent multi-hop reasoning": Strongly supported by the 3× overestimation experiment (Figure 4, Appendix Figure 10) and the Compositional Celebrities co-occurrence analysis (Table 2).
"LLMs demonstrate promising latent multi-hop reasoning without exploiting shortcuts": Supported for country-type bridge entities (~80% composability) but not for year-type entities (~6%), which constitute 96.5% of SOCRATES. The abstract's unqualified phrasing overstates the breadth of the finding.
"Latent composability varies dramatically by bridge entity type": Strongly supported by the country-vs-year comparison (Figure 3a) and the Patchscopes convergent evidence (Figure 6). The finding is robust across models.
"There is a significant gap between latent and CoT composability": Strongly supported by the 12× gap for GPT-4o (Figures 2a vs. 2c), the differential scaling behavior (Figures 2b vs. 2d), and the bridge-entity-type divergence (Figures 3a vs. 3b).
"Latent reasoning marginally improves with model scale": Supported with qualifications—the improvements are consistent but small (6.7 percentage points GPT-4o vs. GPT-4o mini, 2.4 points Gemini 1.5 Pro vs. Flash), and denominator sizes for these comparisons are not reported.
"Latent multi-hop reasoning emerges during pretraining": Supported as existence proof by the OLMo analysis (13 success cases, 12 showing the expected emergence pattern), but the small sample size prevents generalization.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Unaccounted for in the Headline Numbers

The assumption or constraint. The entire shortcut-free evaluation framework depends on the ability to verify that head and answer entities never co-occur in any pretraining document—a process that requires checking all alias combinations against a 4.8B-document proxy corpus using the WIMBD API, plus additional Google Search validation, plus LLM-based bridge entity inferrability checks, plus ablated query testing during evaluation. The paper explicitly acknowledges in Section 4.1, Step 3 that this approximation imposes a practical burden:

"While this approximation cannot guarantee complete exclusion of co-occurring entities without access to exact pretraining corpora, we validate our approach using Google Search for web-wide co-occurrence verification"

And the evaluation procedure described in Section 5.1 requires running additional ablated queries for every test case to detect guessability, meaning the total inference cost per test case is substantially higher than simply administering the multi-hop query.

The consequence. A practitioner wanting to evaluate latent multi-hop reasoning in their own model—or extend SOCRATES to new relation types, new facts, or different domains—faces a substantial practical barrier. The co-occurrence checking pipeline requires: (1) access to a large Elasticsearch index over multiple pretraining corpora via the WIMBD API (or equivalent infrastructure), (2) the ability to query all alias pairs for every candidate test case (which may number in the tens or hundreds of thousands before filtering), (3) running LLM-based inferrability checks (GPT-3.5 Turbo, Claude 3 Haiku) for certain relation types, and (4) during evaluation, running ablated queries alongside each test query and scanning completions for bridge entity generation and multiple-choice enumeration patterns. The paper reports none of these costs—not in terms of API calls, compute hours, or engineering effort—making it impossible to assess whether the methodology is practical to adopt or extend. The consequence is not that SOCRATES is invalid, but that the framework does not come with a recipe for scaling to new problems, and the cost of constructing an equivalent dataset for a different domain or model family is unknown and potentially prohibitive.

What evidence exists in the paper. The pipeline is described across Sections 4.1, 5.1, and Appendices A.2, A.3, B.1, and C.3, but no wall-clock time, compute budget, or API cost is reported for any step. The paper states that the initial Wikidata extraction produces approximately 100K candidate fact pairs, which are reduced to approximately 32K after co-occurrence filtering and to 7,232 after further quality filtering and down-sampling—a cumulative elimination rate of approximately 93%. This implies that constructing 7,232 test cases required processing and discarding approximately 93K candidates, each of which required alias-pair co-occurrence checks across millions to billions of documents. The WIMBD API is described but its query latency or throughput is not quantified. The Google Search validation (Appendix C.3) required checking co-occurrence against approximately 400 billion indexed documents—a cost that is not estimated.

Mitigation status. The paper does not attempt to reduce or amortize the construction cost, nor does it provide estimates. It suggests (Section 7, Limitations) that alternative approaches "such as pretraining or finetuning models to directly predict difficulty" could help in the analogous context of difficulty estimation (a suggestion from the earlier example paper, not from SOCRATES itself), but SOCRATES offers no analogous suggestion for reducing co-occurrence checking overhead. The methodology is presented as a one-time cost borne by the dataset authors, with no discussion of how practitioners might replicate or extend it affordably.

Latent Multi-Hop Reasoning Effectively Fails for Most Query Types, Not Just a Few

The assumption or constraint. The paper constructs SOCRATES as a general evaluation framework for latent multi-hop reasoning, but the co-occurrence filtering process inherently skews the dataset toward year-type bridge entity queries—which constitute 6,975 of 7,232 total test cases, or 96.5% of the dataset (Table 1). This is not a sampling choice but a direct consequence of the filtering: country-type, city-type, and university-type compositions are far more likely to have head-answer entity co-occurrences in natural text, and thus are systematically eliminated at much higher rates. The paper frames this as a feature—it demonstrates how rare genuinely shortcut-free multi-hop queries are—but it also means that the dataset provides almost no statistical power for evaluating performance on non-year bridge entity types.

The consequence is that the paper's main behavioral finding—that latent composability is low overall (8.4% for Claude 3.5 Sonnet, 7.6% for GPT-4o, Figure 2a)—is almost entirely driven by year-type queries, where composability is ~6%. For the query types where composability is interestingly high (country-type, ~80%), the dataset contains only 166 test cases spread across 7 sub-types, and the number of cases where any given model knows both single-hop facts (the denominator for composability) is substantially smaller. The city and university subsets are even smaller (33 and 58 total test cases, with denominator sizes rarely exceeding 20 for any model). This means the paper cannot make statistically reliable claims about composability on non-year query types, even though those are precisely the types where the strongest evidence for genuine latent reasoning exists.

What evidence exists in the paper. Table 1 shows the raw counts by relation composition type and bridge entity type: year (6,975), country (166), university (58), city (33). The brute-force denominator sizes are visible in Figures 3a and Appendix Figure 7 as the x-axis ranges: for country-type, the maximum number of cases where both single-hop facts are known (across all models) is approximately 120; for city-type, it is approximately 20; for university-type, it is approximately 25. These small denominators mean that a single model's composability on country-type queries (e.g., GPT-4o at 84.5%) might be based on as few as 80–100 successful multi-hop cases. The paper does not report exact denominator sizes per model per bridge entity type, making it impossible to assess the variance of these estimates.

Mitigation status. The paper acknowledges the distributional skew implicitly by reporting per-type results (Figures 3a, 3b, Appendix Figures 7, 8) and only plotting data points when denominators are "statistically significant" (though no explicit threshold is stated, Appendix Figure 10 uses a threshold of 30 cases). However, the paper does not treat the small non-year denominators as a limitation that qualifies its conclusions. The abstract and introduction describe latent composability as varying "dramatically across different types of queries" without noting that the dramatic variation is estimated from very different sample sizes—~80% composability on country-type queries might have a confidence interval of ±10 percentage points or more given the small denominator, while ~6% composability on year-type queries is estimated from thousands of cases and has a narrow confidence interval. The normalized slope metric partially addresses denominator concerns by measuring trends, but the point estimates of composability per type remain unreliable for all non-year types. A practitioner reading that "the best models achieve 80% latent composability" for country-type queries should know this estimate is based on roughly two orders of magnitude fewer test cases than the overall 7.6% figure.

The Framework Provides No Mechanistic Explanation for Why Certain Query Types Succeed, Limiting Generalization

The assumption or constraint. The paper demonstrates that latent composability varies dramatically by bridge entity type (country: ~80%, year: ~6%) but provides no causal explanation for why. The Patchscopes analysis (Figure 6, Appendix C.4) shows that bridge entity representations are constructed more often for country-type queries, but this is a correlational description, not a causal mechanism—it tells us that the model's internal state differs between successful and unsuccessful query types, but not what causes that difference. The paper's speculative discussion (Appendix D.2) suggests that "country-related facts might be more frequently learned in composition during pretraining" or that "extending these findings to pretraining remains an untested hypothesis that warrants future investigation."

The consequence. Without a mechanistic understanding, the framework provides no guidance for predicting which new query types will support latent reasoning without running a full evaluation. A practitioner with a new domain—say, scientific facts connected through chemical compounds, or historical facts connected through dynasties—cannot use SOCRATES's findings to estimate whether their query type will behave like country-type (high composability) or year-type (low composability). The paper's finding that relational arity (the number of entities mapping to the same bridge entity value) correlates with composability—country: few entities per country, year: many entities per year—is suggestive but untested beyond the four types in SOCRATES. More importantly, without knowing why arity matters—is it a training data frequency effect, an architectural limitation, a representational geometry issue?—the field cannot design interventions to improve latent reasoning on high-arity bridge types. Should we modify training data to present year-based compositions more frequently? Change the architecture to better handle many-to-one mappings? Provide different representational inductive biases? None of these questions can be answered from the paper's current evidence.

What evidence exists in the paper. The Patchscopes analysis (Figure 6) provides the only mechanistic window, and it is limited to Mistral 7B v0.3 (a single relatively small model) and shows only that bridge entity representations are constructed more often for country-type queries, not why. The OLMo emergence analysis (Figure 5, Appendix C.5) provides temporal evidence that single-hop learning precedes multi-hop success in 12 of 13 successful cases, but again this is a description of the learning dynamics, not an explanation of them. The paper discusses the theoretical connection to Peng et al. (2024) on high-arity relations (Appendix D.1, D.2) but notes this "remains an untested hypothesis." The CoT error decomposition for Claude 3.5 Sonnet (96.0% of failures from incorrect bridge entity generation, Appendix D.3) points toward the first-hop retrieval as the bottleneck, but does not explain why first-hop retrieval is easier under CoT or for country-type queries.

Mitigation status. The paper is transparent about the speculative nature of its mechanistic interpretations, using hedging language throughout: "we speculate" (Section 6.2), "one speculative explanation" (Appendix D.2), "we emphasize that extending these findings to pretraining remains an untested hypothesis" (Appendix D.2). This is appropriate given the scope of the work, but it means the paper's contribution is primarily diagnostic (showing that the variation exists and ruling out shortcut-based explanations) rather than explanatory (showing what causes the variation). A practitioner hoping to improve latent multi-hop reasoning in their models learns that it varies by bridge entity type, but not what to change to make year-type compositions work.

Single Benchmark, Single Knowledge Source, and Limited Factual Diversity

The assumption or constraint. All test cases in SOCRATES are drawn from Wikidata, all queries are templated as fill-in-the-blank completions of incomplete sentences, and the entire evaluation is conducted on a single constructed dataset rather than naturally occurring text. The paper explicitly limits its scope to "factual knowledge" as encoded in a structured knowledge graph, acknowledging in the Limitations section that it does "not test other forms of compositional reasoning such as comparisons because if the answer is binary, it is hard to rule out the cases of guessing."

The consequence. The paper's findings—both the positive results for country-type queries and the negative results for year-type queries—are doubly conditional: they apply to (1) facts as represented in Wikidata, and (2) queries phrased using the specific 16 templates per relation composition type. Wikidata is a particular knowledge source with its own coverage biases, entity granularity choices, and alias completeness. Facts that are well-represented in Wikidata (Nobel Prize winners, Olympic host cities, national anthems) may differ systematically from facts in other structured knowledge bases or from facts as they appear in natural text. The template-based query construction, while designed for diversity (16 templates per type), still constrains the linguistic forms in which the queries appear, and models may have different levels of familiarity with these specific phrasings. Critically, the paper does not test whether latent composability is robust to paraphrase—would a model that succeeds on "In e1's year of birth, the Nobel Prize in Physics was awarded to" also succeed on "When e1 was born, the physicist receiving the Nobel that year was"? If composability is fragile to surface form, then the high country-type composability may reflect template-specific behavior rather than robust compositional reasoning.

Furthermore, the restriction to fill-in-the-blank format (rather than question-answering) and the CoT-suppressing instruction ("Fill in the blank. Write down only what goes in the blank. Do not explain your answer.") creates an evaluation context that may not match how these models are used in practice. A model that achieves 80% latent composability on country-type queries in this constrained format might perform very differently when asked the same factual composition in a conversational setting, where the model's default behavior is to generate more verbose, explanatory responses.

What evidence exists in the paper. The paper does not report any experiment varying the knowledge source (e.g., using Freebase or DBpedia instead of Wikidata), the query format (e.g., using questions instead of fill-in-the-blank, or varying the templates systematically to test paraphrastic robustness), or the linguistic framing. The template sampling is random (one template per test case from the 16 possible combinations), but there is no analysis of whether performance varies systematically across templates—some templates might be more natural or more familiar to models than others, and the random sampling may mask template-dependent effects. The paper does test alternative instructions (CoT-triggering, internal think-step-by-step, Appendix D.3) but all within the fill-in-the-blank paradigm.

Mitigation status. The paper does not claim broader generalization beyond Wikidata-derived factual queries in the fill-in-the-blank format, so this limitation is partially self-bounded. However, the framing in the introduction and abstract—"How well do today's widely-used LLMs perform latent multi-hop reasoning over factual knowledge?"—implies a broader scope than the evaluation actually covers. The Limitations section (Section 7) acknowledges the exclusion of "other forms of compositional reasoning such as comparisons" and the restriction to "two hops" (not more), but does not discuss the Wikidata-specificity or template-specificity of the evaluation. A practitioner reading the paper should understand that the reported composability numbers apply to a specific class of templated queries drawn from a specific knowledge graph; whether they generalize to other formulations of the same underlying facts is unknown and untested.

The Evaluation Cannot Distinguish Genuine Latent Composition from Alternative Internal Mechanisms

The assumption or constraint. The paper defines latent multi-hop reasoning as "latently recalling and composing learned single-hop facts to answer multi-hop queries" (Section 1) and operationalizes this through the latent composability metric: the model correctly answers the multi-hop query while correctly answering both single-hop queries, without generating the bridge entity, and without the query being guessable from ablated versions. However, this behavioral signature does not uniquely identify the claimed mechanism of composing two separately learned facts. There are alternative internal mechanisms that would produce the same behavioral pattern without involving composition in the sense the paper intends.

For example, the model might have learned a direct multi-hop fact r2 ∘ r1(e1) = e3 from a training sequence that contained the multi-hop composition without explicitly listing the bridge entity (e.g., "Scarlett Johansson, born in 1984, grew up in the United States" encodes the composed fact without stating the bridge entity separately as a disconnected fact). The paper's co-occurrence filter removes cases where e1 and e3 co-occur, but it does not remove cases where the composed fact itself appears in training in a way that does not involve e1-e3 co-occurrence—for instance, if "In 1984, the Summer Olympics were held in Los Angeles, United States" and "Scarlett Johansson was born on November 22, 1984" appear in the same document but not in the same sentence or paragraph, they would be caught by the co-occurrence filter only if "Scarlett Johansson" and "United States" appear together elsewhere in the document. If they appear in different sections of a long Wikipedia article about 1984, they might not co-occur within the document-level check. More subtly, the model might learn to answer "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of" by pattern-matching the year 1984 from its knowledge of Scarlett Johansson's birth year, then retrieving the 1984 Olympics host country—this is genuine composition (recalling two separate facts and combining them), but the paper provides no positive evidence that this specific mechanism is what drives successful cases, as opposed to the model having memorized the composed fact through a training artifact not captured by the co-occurrence filter.

The consequence. Even for the country-type queries where latent composability is high (~80%), we cannot be certain that the model is composing facts "on the fly" rather than retrieving a previously learned composed association. The co-occurrence filter is an excellent negative control—it rules out one class of shortcut (direct e1-e3 association from co-occurrence)—but it does not positively confirm the compositional mechanism. This matters for the practical motivations outlined in Section 1: if the model's success on country-type queries reflects memorization of composed facts (through co-occurrence of the single-hop facts in training, not the head and answer entities), then editing a single-hop fact (changing a country's national anthem) would fail to propagate to the multi-hop query, just as it would under the direct shortcut regime. The paper's knowledge editing motivation requires not just that e1 and e3 never co-occurred, but that the model's internal computation genuinely separates and recombines the two facts—a much stronger claim that the behavioral evaluation cannot verify.

What evidence exists in the paper. The Patchscopes experiments (Figure 6) provide some convergent evidence: if the model constructs a representation of the bridge entity from the descriptive mention, this is at least consistent with a two-step composition mechanism (first retrieve the bridge entity, then use it to retrieve the answer). However, as the paper notes, the extraction rate is a lower bound, and successful extraction does not prove that the bridge entity representation is causally necessary for the answer—the model might be constructing the bridge entity representation as a byproduct of retrieving the answer through a different pathway. The paper does not perform causal intervention experiments (e.g., patching the bridge entity representation to an incorrect value and measuring whether the answer changes) that would establish whether the bridge entity representation is causally involved in answer production. The OLMo analysis (Figure 5) shows temporal emergence (single-hop then multi-hop) which is consistent with composition but, again, could also be consistent with the model learning the composed fact later than the individual facts because composed facts are rarer in the training data.

Mitigation status. The paper does not claim to have proven the compositional mechanism, and its framing is appropriately cautious about this: "While we cannot guarantee that the head and answer entities of every test query of SOCRATES would have never been learned in a single pretraining sequence for every model that we evaluate, we believe that our dataset construction that utilizes document co-occurrence counts of multiple pretraining corpora provides a tight approximation" (Limitations, Section 7). The paper's contribution is to raise the bar for what counts as evidence of latent multi-hop reasoning—from assumption-based filtering to empirical co-occurrence verification—not to provide mechanistic proof. However, a practitioner reading that models achieve 80% latent composability on country-type queries should understand that this 80% is an upper bound on genuine composition: it establishes that composition is sufficient to explain the performance (the model knows both single-hop facts and the query cannot be solved by shortcuts the paper checks for), but not that composition is necessary or that alternative pathways have been ruled out.

The Paper Does Not Provide a Path Toward Improving Latent Multi-Hop Reasoning

The assumption or constraint. SOCRATES is designed as an evaluation framework, not a training methodology. The paper's goal is to measure whether latent multi-hop reasoning exists in pretrained LLMs and under what conditions—not to improve it. The authors are explicit about this scope in Section 1: "If today's best models... struggle to perform latent reasoning, then the current pretraining, instruction-tuning, and scaling paradigm of LLMs may be insufficient for robust development of latent multi-hop reasoning abilities. Thus, we would need to adopt changes in this paradigm or the architecture of models to enhance their ability... However, if there are certain cases where today's LLMs show robust latent reasoning, we could further study these cases to find the underlying causes that make latent reasoning emerge during pretraining."

The consequence. The paper identifies a significant capability gap—latent composability of ~6% for year-type queries versus ~80% for country-type queries, and an overall latent-CoT gap of 7.6% vs. 92.8% for GPT-4o—but provides no actionable guidance for closing it. The finding that model scale improves CoT composability dramatically but latent composability only marginally (Figures 2b vs. 2d) implies that simply training larger models will not solve the latent reasoning problem. The finding that instructing models to think step-by-step internally does not improve performance (Appendix D.3, 6.1% vs. 8.4% for Claude 3.5 Sonnet) suggests that prompting-based interventions are insufficient. The speculative discussion about training data composition patterns (Appendix D.2) suggests that modifying pretraining data to include more compositional examples might help, but provides no evidence.

A practitioner who wants to deploy an LLM for multi-hop factual queries faces a binary choice under the paper's findings: either (1) use CoT and accept the inference cost of generating intermediate tokens, achieving high composability (~90%+) across all bridge entity types, or (2) attempt latent reasoning and accept near-zero accuracy on year-type queries (which, based on SOCRATES's distribution, may be the most common query type in any realistically diverse deployment). The paper does not explore hybrid strategies—using latent reasoning for query types where it works (country-type) and falling back to CoT for query types where it doesn't—nor does it propose any training intervention (fine-tuning on compositional tasks, representation learning objectives, architectural modifications) that might improve latent reasoning. The failure of the internal think-step-by-step instruction (Appendix D.3) is particularly discouraging: it suggests that the benefit of CoT cannot be trivially internalized through prompting, and that more fundamental changes to how models process and compose factual knowledge are needed.

What evidence exists in the paper. The gap between latent and CoT composability is thoroughly documented (Figures 2a vs. 2c, 2b vs. 2d, 3a vs. 3b, Appendix Figure 9). The internal think-step-by-step ablation (Appendix D.3, Section D.3) shows that simply instructing models to reason internally does not close the gap. The scale analysis (Figures 2b, 2d) shows that scaling benefits CoT much more than latent reasoning, implying that continued pretraining scale-up is not a solution. The paper does not include any experiment that attempts to improve latent composability—no fine-tuning runs, no architecture comparisons, no training data interventions, no inference-time strategies beyond the single-prompt CoT-suppression instruction.

Mitigation status. The paper is transparent that it is an evaluation and analysis contribution, not a methods contribution, and the Limitations section (Section 7) does not claim otherwise. The acknowledgment that the findings "suggest substantial room for improvement in how LLMs internally compose their knowledge" (Section 7) is appropriately hedged. However, the paper's framing in Section 1 suggests a two-branch decision tree: if models can reason latently, study why; if they cannot, change the paradigm. The findings reveal a more complex picture—models can reason latently for some query types but not others—and the paper does not explicitly address what this mixed result implies for the decision tree. A practitioner is left with a clear diagnosis but no prescription. The paper would be stronger if it explicitly discussed what kinds of interventions the findings motivate (e.g., training data augmentation with compositional examples for year-type facts, architectural modifications to improve internal representation of high-arity relations, or distillation from CoT to latent reasoning pathways) even if it does not test them.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not propose a new model, training algorithm, or inference strategy. It proposes something more foundational: a methodological standard. The central shift it introduces is epistemological rather than technical—it demonstrates that the field's existing evidence base for latent multi-hop reasoning in LLMs is largely uninterpretable, and it provides the first framework for generating interpretable evidence. This is not an incremental refinement of prior evaluation protocols but a methodological corrective that, if adopted, would invalidate a substantial fraction of previously published claims about latent compositional reasoning in pretrained models.

The key reframing is this: latent multi-hop reasoning cannot be evaluated by constructing queries designed to be "unlikely" to appear in training; it must be evaluated by empirically verifying what appeared in training (or a close proxy thereof) and excluding queries where the answer could be reached through co-occurrence-based shortcuts. The paper shows that assumption-based filtering—the dominant approach in prior work—fails catastrophically. The 85.30% co-occurrence contamination rate found in the Compositional Celebrities dataset (Table 2) is not a minor oversight but a fundamental failure of the assumption-based methodology: the data construction heuristics that were supposed to prevent shortcuts did not work, because the structure of co-occurrence in natural text is not predictable from the logical relationships between facts. Entities that seem unrelated (a minor celebrity and a Nobel Prize winner born in the same year) routinely co-appear in documents organized by year, category, or geography. The paper's proxy corpus methodology—using 4.8B documents to approximate co-occurrence, validated against Google Search—provides an operational path forward for any researcher who cannot access proprietary training data: rather than guessing what models might have seen, check against the largest available public corpora and quantify the approximation error.

The 3× overestimation of latent composability when shortcuts are not controlled (Figure 4, Appendix Figure 10) means that prior work's positive findings about latent multi-hop reasoning must be re-evaluated with skepticism. The paper does not claim that all prior results are wrong—it shows that the measured composability is contaminated by an unknown fraction of shortcut-exploiting cases, making it impossible to determine what portion of previously reported performance reflects genuine composition. This shifts the burden of proof for new work in this area: any future claim about latent multi-hop reasoning in pretrained LLMs that does not include empirical co-occurrence filtering and guessability exclusion cannot be taken at face value. The paper does not make prior work obsolete, but it makes it uninterpretable pending re-analysis under the new standards.

The paper also resolves a tension that was latent in the literature but never explicitly articulated. Prior work had documented that LLMs struggle with multi-hop reasoning under certain conditions—Biran et al. (2024) found that models "hop too late" (construct bridge entity representations too late in the forward pass to be useful), and Ju et al. (2024) found that multi-hop knowledge editing fails when shortcuts exist. Meanwhile, other work (Yang et al., 2024b; Li et al., 2024) found evidence of latent bridge entity representations. The current paper reconciles these findings by showing that both observations can be true simultaneously: models can construct bridge entity representations and compose facts latently for certain compositional structures (country-type bridge entities, ~80% composability), while failing almost completely for others (year-type bridge entities, ~6% composability). The contradiction was not in the models but in the query distributions—different studies were implicitly testing on different mixtures of compositional structures without controlling for that mixture. The paper's per-bridge-entity-type breakdown makes this explicit and provides a framework for avoiding the confusion in future work.

The paper also redirects the research agenda around model scale. The finding that latent composability improves only marginally with model scale (GPT-4o vs. GPT-4o mini: 6.7 percentage points; Gemini 1.5 Pro vs. Flash: 2.4 percentage points; Figure 2b) while CoT composability improves dramatically (Figure 2d) challenges the "scale is all you need" narrative that has dominated LLM research. If simply making models larger does not substantially improve latent reasoning, then the bottleneck for latent multi-hop reasoning is not primarily capacity or general intelligence but something structural—potentially the way facts are presented in training data, the architecture's ability to internally represent and compose high-arity relations, or the absence of explicit compositional supervision during pretraining. This reframes latent reasoning from a capability that will naturally emerge with sufficient scale to a capability that may require targeted interventions in training data, architecture, or training objectives. The research direction "just train bigger models and latent reasoning will improve" becomes less attractive; the direction "identify and address the specific structural barriers to latent composition" becomes more attractive.

Finally, the paper's analysis of the latent-CoT gap—GPT-4o achieves 92.8% CoT composability vs. 7.6% latent composability, with the bridge-entity-type disparity largely eliminated under CoT (Figures 3a vs. 3b)—establishes that the bottleneck for latent reasoning is not knowledge coverage or general reasoning ability. The same model that can compose facts with near-perfect accuracy when allowed to generate intermediate tokens cannot do so when forced to reason silently, despite "knowing" both constituent facts. This implies that token generation is not merely an externalization of an internal computation that could be performed silently; it plays a causal role in enabling the computation. The failure of the internal think-step-by-step instruction (6.1% composability for Claude 3.5 Sonnet, Appendix D.3) reinforces this: telling the model to reason internally without generating tokens does not replicate the benefit of actual token generation. This finding pushes the research agenda toward understanding the computational role of autoregressive generation in reasoning—a question that goes beyond multi-hop factual composition to the foundations of how transformer language models perform multi-step inference.

Follow-Up Research This Work Enables

Training data composition analysis to explain the bridge-entity-type disparity. The paper's central finding—~80% latent composability for country-type queries vs. ~6% for year-type queries—lacks a causal explanation. The Patchscopes analysis (Figure 6) shows that bridge entity representations are constructed more often for country-type queries, but not why. The most tractable follow-up would analyze the pretraining data composition for the specific relation types in SOCRATES. Using OLMo's fully accessible pretraining data (all sequences across 557K steps) or Dolma for open models, a researcher could measure: (1) how often each single-hop fact appears in training, (2) how often the two single-hop facts for a given test case appear in the same training sequence (not the head and answer entities, which are filtered, but the single-hop facts themselves—for example, how often "Scarlett Johansson was born in 1984" and "The 1984 Summer Olympics were in the US" appear in the same document or sequence), and (3) whether models that see more compositional exposure to certain bridge entity types develop higher latent composability for those types. The hypothesis from the paper's speculation (Appendix D.2) is that country-related facts are more often presented compositionally (e.g., a Wikipedia country infobox listing anthem, ISO code, founding year together), while year-related facts are distributed across temporally organized documents. This analysis would either confirm the training data composition hypothesis—providing a clear lever for improving latent reasoning (modify pretraining data to include more compositional examples for high-arity bridge types)—or refute it, sending the search for an explanation toward architectural or representational factors. A strong follow-up would compute, for each test case in SOCRATES, the co-occurrence frequency of (e1, e2) and (e2, e3) in training sequences, and correlate this with whether the model successfully answers the multi-hop query, controlling for single-hop accuracy.

Causal intervention experiments to verify the compositional mechanism. The paper's behavioral evaluation (latent composability metric) and correlational representational analysis (Patchscopes) cannot distinguish between genuine on-the-fly composition and retrieval of a composed fact that was learned through co-occurrence of the single-hop facts (not the head-answer entities). A follow-up using causal mediation analysis on open-source models like OLMo or Mistral would address this directly. The design: identify test cases where the model successfully performs latent multi-hop reasoning (both single-hop facts known, multi-hop correct, not guessable). Using activation patching (Vig et al., 2020; Meng et al., 2022), replace the model's internal representation of the bridge entity (as identified by Patchscopes, Figure 6) with the representation of a different bridge entity—for instance, if the model is processing "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of," patch the representation of "1984" to "1996" and measure whether the answer changes from "United States" to the 1996 Olympics host country. If the answer changes appropriately, this provides causal evidence that the bridge entity representation mediates the multi-hop answer—the model is genuinely retrieving the bridge entity and using it to retrieve the second fact. If the answer does not change, or changes inappropriately, the model's successful multi-hop answering may rely on a different pathway (e.g., direct composed-fact retrieval). This experiment would transform the paper's correlational evidence into causal evidence and directly test the compositional mechanism the paper hypothesizes. The OLMo checkpoints would allow tracking when this causal pathway emerges during pretraining.

Paraphrastic robustness evaluation to test whether latent composability is template-dependent. SOCRATES uses 16 handcrafted templates per relation composition type, randomly sampled per test case, but the paper does not analyze whether composability varies across templates. A critical stress-test of the paper's findings would be to construct paraphrased versions of all SOCRATES queries using diverse surface forms—not just different templates for the same syntactic structure (which the paper already includes) but genuinely different syntactic and lexical realizations. For example, "In the year Scarlett Johansson was born, the Summer Olympics were hosted in the country of" could be paraphrased as "The Summer Olympics took place in which country the year Scarlett Johansson entered the world?" or "Scarlett Johansson's birth year: the Summer Olympics host country that year was." If latent composability drops substantially under paraphrase for query types where the paper reports high composability (country-type, ~80%), this would suggest that the paper's positive findings reflect template-specific behavior—the model has learned to associate specific surface patterns with the compositional operation—rather than robust compositional reasoning. If composability is stable under paraphrase, it strengthens the paper's claim of genuine latent composition. This experiment is straightforward to implement (a few person-hours of template construction, then running the same evaluation pipeline) and would provide essential calibration for how seriously to take the reported composability numbers.

Extension to multi-hop reasoning beyond two hops. The paper restricts its evaluation to two-hop compositions because "latent two-hop composability is already quite low, and adding more complexity to the problem may lower it to zero success cases" (Limitations, Section 7). However, this means the paper cannot address the question of whether the compositional mechanism it documents (for country-type queries) composes recursively—can a model that can compose two facts through a country bridge entity also compose three facts through country-year or country-person bridge entity chains? A natural extension would construct three-hop queries from the same Wikidata facts, using the same co-occurrence filtering methodology, but with a focus on the query types where two-hop composability is already high (country-type). For instance: "The national anthem of the country where the Summer Olympics were hosted in the birth year of the founder of Company X" chains person → birth year → Olympics host country → national anthem (three hops through year and country bridge entities). If latent composability remains non-trivial for these chains, it would suggest that the compositional mechanism extends to deeper compositions for certain bridge entity types. If it collapses to near-zero, it would reveal a depth limit to latent composition that is independent of bridge entity type, suggesting that latent reasoning has a fixed computational budget (perhaps related to the number of layers or attention heads available for sequential retrieval operations within a single forward pass) that is exhausted by two hops for even the "easy" bridge entity types.

Fine-tuning interventions targeting latent compositional ability. The paper documents a substantial latent-CoT gap (GPT-4o: 7.6% latent vs. 92.8% CoT, Figure 2a vs. 2c) and shows that instruction-based interventions (internal think-step-by-step, Appendix D.3) do not close it. This suggests that acquiring the ability to perform the computation latently—without generating intermediate tokens—may require training-time intervention, not just prompting. A natural experiment would be to fine-tune a base model (e.g., OLMo 7B or Mistral 7B) on a dataset of compositional reasoning examples where the model is trained to produce the final answer directly from the multi-hop query, without intermediate steps—essentially distilling CoT reasoning into the model's forward-pass computation. This could be done by: (1) using a strong model (GPT-4o) with CoT to generate correct answers for a large set of multi-hop training queries (sourced from Wikidata with the paper's filtering methodology), (2) fine-tuning the smaller model on these examples with a loss that only supervises the final answer tokens, and (3) evaluating on SOCRATES to see whether latent composability improves, particularly for year-type queries where the baseline is near-zero. A positive result—latent composability approaching CoT composability after fine-tuning—would demonstrate that the latent-CoT gap is a training gap (models were not trained to perform this specific internal computation) rather than an architectural limitation. A negative result—fine-tuning fails to improve latent composability even when the model can learn to produce the correct final answer—would suggest that transformer architectures may be fundamentally limited in their ability to perform multi-step retrieval within a single forward pass, a finding with implications far beyond multi-hop factual reasoning.

Latent reasoning in other modalities and knowledge types. SOCRATES evaluates factual knowledge encoded as Wikidata triplets, queried through natural language templates. The framework—empirical co-occurrence filtering, guessability exclusion via ablation, composability conditioned on single-hop knowledge—is modality-agnostic and knowledge-source-agnostic. A natural extension would apply the same methodology to code generation, where multi-hop queries might take the form "In the programming language created by the person who designed JavaScript, what is the syntax for a list comprehension?" This domain has clean correctness signals (the generated code can be executed) and a different co-occurrence structure (code documentation and tutorials have different entity co-occurrence patterns than encyclopedic text). A second extension would target scientific reasoning, where facts about chemical compounds, biological pathways, or physical laws are connected through intermediate entities (e.g., "The melting point of the compound produced by reacting X with Y"). These domains test whether the paper's finding—that latent composability is bridge-entity-type-dependent—generalizes beyond the specific Wikidata relations studied, or whether it reflects something specific about how Wikidata facts are organized in natural text. A strong cross-domain finding (e.g., year-like bridge entities show low composability across code, science, and Wikidata facts, while entity-like bridge entities show high composability) would suggest a general architectural or training-data principle; domain-specific variation would suggest that the training data composition hypothesis (Appendix D.2) is the dominant factor.

Practical Applications and Downstream Use Cases

Model selection for latency-sensitive factual QA systems. The paper's finding that latent composability varies from ~80% (country-type) to ~6% (year-type) for the same model provides actionable guidance for practitioners building QA systems that must answer multi-hop factual queries without the latency overhead of Chain-of-Thought. In a production setting where queries arrive with a strict latency budget (e.g., voice assistants, real-time chatbots), a system can use the paper's bridge-entity-type taxonomy to route queries based on expected latent reasoning difficulty. A lightweight classifier (trained on SOCRATES-style templates or using a few-shot LLM prompt) could detect whether an incoming multi-hop query involves a country-type bridge entity (high expected latent composability, can be answered directly) or a year-type bridge entity (low expected latent composability, should be routed to a CoT-capable pipeline or escalated to a larger model). The concrete benefit: for country-type queries, the system avoids the latency and token cost of CoT generation while maintaining ~80% accuracy; for year-type queries, it accepts the CoT overhead because the alternative (latent reasoning) would produce ~6% accuracy. This is not a hypothetical—the paper provides the per-type composability numbers needed to make this routing decision, and the bridge entity type of a query can often be identified from the relation words in the query template (e.g., "in the year" signals a year-type bridge entity, "of the country" signals a country-type bridge entity).

Knowledge graph completion and verification with uncertainty quantification. The paper's methodology can be adapted for evaluating whether an LLM's internal knowledge base supports latent composition of specific fact pairs, which has direct application to knowledge graph completion and fact verification. Given a candidate multi-hop fact r2 ∘ r1(e1) = e3 that is not yet in a knowledge graph, a system could: (1) check whether the constituent single-hop facts are in the LLM's parametric knowledge (by querying the single-hop queries and checking for correct answers), (2) check whether the head and answer entities co-occur in available corpora (using the paper's WIMBD-based approach), and (3) if both single-hop facts are known and the entities never co-occur, measure whether the LLM correctly answers the multi-hop query. A correct answer under these conditions provides stronger evidence that the candidate multi-hop fact is genuinely implied by the model's knowledge rather than being a memorized association—a signal that can be used to prioritize fact candidates for human verification or to weight LLM-generated knowledge graph completions by confidence. The paper's 80% composability for country-type queries means this signal is fairly reliable for that compositional structure; the 6% composability for year-type queries means the signal is weak (most genuinely implied year-type multi-hop facts will not be answered correctly by the model) and alternative verification methods would be needed.

Auditing deployed LLMs for non-transparent compositional inferences (safety monitoring). A key motivation the paper identifies (Section 1) is that latent reasoning is "less visible and hard to monitor given the opaque computations in LLMs." SOCRATES provides a concrete tool for probing whether a deployed model engages in non-transparent compositional reasoning in domains where such reasoning could be consequential. Consider a model deployed for medical question-answering, where a multi-hop query might be "The drug interaction risk for the medication prescribed for the condition caused by the patient's genetic marker is." If the model answers this latently—correctly composing facts about the genetic marker → condition → medication → drug interaction, all without generating intermediate reasoning steps—the answer may be correct but the reasoning pathway is unauditable. An auditor could construct SOCRATES-style test probes for the specific medical knowledge domain, with co-occurrence filtering based on medical literature corpora, and measure whether the model exhibits latent composability for the relevant compositional structures. If latent composability is high, the auditor knows that the model can perform non-transparent multi-step medical reasoning, which may violate regulatory requirements for explainability. If latent composability is low, the auditor has evidence that the model's medical answers likely do not involve latent multi-hop composition—the model is either using CoT (if allowed), guessing, or relying on surface-level pattern matching. This transforms SOCRATES from a research evaluation tool into a safety audit instrument for domains where reasoning transparency matters.