SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2501.00656 · 2025

2 OLMo 2 Furious

arXiv · PDF · Open in the Atlas

Code that ran

16 of 21 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 11 have no contract verdict; 4 failures of our instrument; 5 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2501.00656.json · badge: /api/ran/2501.00656.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
allenai/OLMo-core canonical (classifier label)
classifier basis not recorded on the link
8 ran · 3 no recorded run
allenai/olmo canonical (classifier label)
classifier basis not recorded on the link
5 ran · 1 no recorded run
allenai/olmes canonical (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
FunctionStatusWhere it lives
all_to_all_single Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/distributed/nn.py
code served (permissive licence) · get_code("60bd6b2361f5a8b0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (8, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.distributed as dist
from unittest.mock import MagicMock

torch.manual_seed(0)

# Create a mock process group
mock_group = MagicMock(spec=dist.ProcessGroup)

# Create input tensor with shape [8, 4] (8 divisible by typical world_size of 2 or 4)
input_tensor = torch.randn(8, 4, dtype=torch.float32)

# Define output split sizes for dim 0
output_split_sizes = [4, 4]

# Define input split sizes for dim 0
input_split_sizes = [4, 4]

ARGS = {
    "group": mock_group,
    "input_": input_tensor,
    "output_split_sizes": output_split_sizes,
    "input_split_sizes": input_split_sizes,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (8, 4) — shape (8, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
beta_feature Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/doc_utils.py
code served (permissive licence) · get_code("903f4474fe15cdaf")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

# Create a simple test class to pass as argument
class TestClass:
    """Original docstring for test class."""
    pass

# Create a simple test function to pass as argument
def test_function():
    """Original docstring for test function."""
    pass

# Test with a class
test_obj_class = TestClass()

# Test with a function
test_obj_function = test_function

# The beta_feature function takes a single parameter 'f' which can be
# either a class or function. We'll test with a function.
ARGS = {
    'f': test_function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
causal_attention_bias Ran
ran, honoured the contract we drafted
allenai/olmo/olmo/model.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from hed-ucas/Layer-wise-Learning-Rate, is pointer only (licence: NONE) · get_code("f9abf6d74699cc1c")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from hed-ucas/Layer-wise-Learning-Rate, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

decode_key Ran
ran; our contract draft was wrong, not the code
allenai/olmo/olmo/safetensors_util.py
code served (permissive licence) · get_code("f0c3a597e3ccfaf6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned STKey. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import base64
import pickle
from dataclasses import dataclass
from typing import Dict, Optional, Tuple

@dataclass(eq=True, frozen=True)
class STKey:
    keys: Tuple
    value_is_pickled: bool

def decode_key(key: str) -> STKey:
    b = base64.urlsafe_b64decode(key)
    keys, value_is_pickled = pickle.loads(b)
    return STKey(keys, value_is_pickled)

# Create a valid encoded key
# First, create the data structure that will be pickled
keys_tuple = ("key1", "key2", "key3")
value_is_pickled_flag = True

# Pickle the data
data_to_pickle = (keys_tuple, value_is_pickled_flag)
pickled_data = pickle.dumps(data_to_pickle)

# Base64 encode it
encoded_key = base64.urlsafe_b64encode(pickled_data).decode('ascii')

ARGS = {
    "key": encoded_key
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type STKey — a STKey output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a STKey output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
encode_key Ran
ran; our contract draft was wrong, not the code
allenai/olmo/olmo/safetensors_util.py
code served (permissive licence) · get_code("e3246d51c7d7535c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import base64
import pickle
from dataclasses import dataclass
from typing import Tuple

@dataclass(eq=True, frozen=True)
class STKey:
    keys: Tuple
    value_is_pickled: bool

ARGS = {
    "key": STKey(
        keys=("model_state", "layer_1", 42),
        value_is_pickled=True
    )
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
env_bool Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/utils.py
code served (permissive licence) · get_code("1ab94002f679ebd2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
from typing import Union, Sequence

# Clear any existing environment variables that might interfere
for key in list(os.environ.keys()):
    if key.startswith('TEST_'):
        del os.environ[key]

# Test case 1: single string name with truthy value
os.environ['TEST_VAR_TRUE'] = 'true'

# Test case 2: sequence of names
os.environ['TEST_VAR_1'] = '1'
os.environ['TEST_VAR_YES'] = 'yes'

ARGS = {
    'name': 'TEST_VAR_TRUE',
    'default': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
extract_think_answer Ran
ran on a synthesized input
allenai/olmes/oe_eval/models/output_processors.py
code served (permissive licence) · get_code("379ba3f9c8a51ff3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import re

torch.manual_seed(0)

# The function extract_think_answer takes a dict with a 'continuation' key
# It extracts reasoning between <think></think> tags and answer between <answer></answer> tags
# It uses basic string operations and regex on the 'continuation' value

ARGS = {
    'output': {
        'continuation': '<think>Let me reason about this problem step by step. First I need to understand what is being asked.</think><answer>The answer is 42</answer>'
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
flatten_dict Ran
ran; our contract draft was wrong, not the code
allenai/olmo/olmo/safetensors_util.py
code served (permissive licence) · get_code("b593a4bbddcc66c3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import pickle
from dataclasses import dataclass
from typing import Dict, Tuple

torch.manual_seed(0)

@dataclass(eq=True, frozen=True)
class STKey:
    keys: Tuple
    value_is_pickled: bool

# Test case 1: Simple dict with tensors and non-tensor values
d = {
    "tensor_key": torch.randn(2, 4),
    "scalar_key": 42,
    "string_key": "hello",
    "nested": {
        "nested_tensor": torch.randn(3, 5),
        "nested_value": 3.14,
    }
}

ARGS = {
    "d": d
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_completion Ran
ran on a synthesized input
allenai/olmes/oe_eval/models/litellm.py
code served (permissive licence) · get_code("7162dfdf480a8995")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned coroutine. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import asyncio
from typing import List, Optional

# Define the ARGS dictionary with valid arguments for get_completion
ARGS = {
    "model": "gpt-3.5-turbo",
    "messages": [
        {"role": "user", "content": "Hello, how are you?"},
        {"role": "assistant", "content": "I'm doing well, thank you!"}
    ],
    "kwargs": {
        "temperature": 0.7,
        "max_tokens": 100,
        "top_p": 0.9
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
litellm — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_fs_local_rank Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/distributed/utils.py
code served (permissive licence) · get_code("32df15687ce14fd7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import torch
import torch.distributed as dist
from unittest.mock import MagicMock, patch

torch.manual_seed(0)

# Setup: We need to provide a group argument (Optional[dist.ProcessGroup])
# The function signature is: get_fs_local_rank(group: Optional[dist.ProcessGroup]=None) -> int

# Create a mock ProcessGroup if needed
mock_process_group = MagicMock(spec=dist.ProcessGroup)

# Since the function checks is_distributed() and reads environment variables,
# we'll set up a scenario where distributed is not initialized (simplest case)
# This makes the function return 0 immediately.

ARGS = {
    'group': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_global_rank Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/distributed/utils.py
code served (permissive licence) · get_code("cf29bba61f4e7b45")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.distributed as dist
from typing import Optional

torch.manual_seed(0)

# Since we cannot actually initialize torch.distributed in a sandbox environment,
# we'll create arguments that work with the function logic.
# The function checks if distributed is available and initialized,
# then uses get_global_rank if a group is provided.

# For group_rank parameter: an integer representing rank within a group
group_rank = 0

# For group parameter: Optional[dist.ProcessGroup]
# We can pass None (safest option in non-distributed context)
# or create a mock ProcessGroup if needed
group = None

ARGS = {
    "group_rank": group_rank,
    "group": group,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_rank Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/distributed/utils.py
code served (permissive licence) · get_code("b32994fbeacb1e9b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.distributed as dist

torch.manual_seed(0)

# The function get_rank() takes an optional group parameter of type Optional[dist.ProcessGroup]
# The function body calls dist.get_rank(group) when is_distributed() is True
# Since we're running in a non-distributed context (dist is not initialized),
# the function will return 0 without actually using the group parameter
# We can pass None as the group parameter

ARGS = {
    "group": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
longest_common_prefix Ran
ran; our contract draft was wrong, not the code
allenai/olmo/hf_olmo/convert_olmo_to_hf.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from hed-ucas/Layer-wise-Learning-Rate, is pointer only (licence: NONE) · get_code("1e05670874fea1ef")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from hed-ucas/Layer-wise-Learning-Rate, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

move_to_device Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/utils.py
code served (permissive licence) · get_code("efa5007ea3ca9d06")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Test case 1: Move a single tensor to device
tensor_obj = torch.randn(2, 4)
device_obj = torch.device('cpu')
non_blocking_obj = False

ARGS = {
    'o': tensor_obj,
    'device': device_obj,
    'non_blocking': non_blocking_obj
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
process_batch Ran
ran on a synthesized input
allenai/olmes/oe_eval/models/litellm.py
code served (permissive licence) · get_code("c85e4b8ba614f924")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned coroutine. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import asyncio
import torch
import torch.nn as nn

torch.manual_seed(0)

# Create mock async coroutines that will be awaited
async def mock_completion_task_1():
    return {"id": 1, "result": "completion_1"}

async def mock_completion_task_2():
    return {"id": 2, "result": "completion_2"}

async def mock_completion_task_3():
    return {"id": 3, "result": "completion_3"}

# Construct completion_tasks as a list of tuples
# Each tuple has (first_element, async_task, third_element)
# The function unpacks as (_, task, _) so we need valid tuple structure
completion_tasks = [
    ("metadata_0", mock_completion_task_1(), {"config": "value1"}),
    ("metadata_1", mock_completion_task_2(), {"config": "value2"}),
    ("metadata_2", mock_completion_task_3(), {"config": "value3"}),
]

ARGS = {
    "completion_tasks": completion_tasks,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rank_matches_filter Ran
ran on a synthesized input
allenai/OLMo-core/src/olmo_core/utils.py
code served (permissive licence) · get_code("b4c909652686eb75")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Analyzing the function:
# - rank_filter: str - a string that can be "all", "*", or comma-separated rank numbers
# - rank: int - an integer rank to test against the filter
# 
# The function tests if a rank matches a filter pattern.
# We need valid example arguments for both parameters.

ARGS = {
    "rank_filter": "0,2,4",
    "rank": 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
all_to_all Not yet run
unverified (harvested, no recorded run)
allenai/OLMo-core/src/olmo_core/distributed/nn.py
code served (permissive licence) · get_code("eef0e57960f509e5")
How it ran

no invocation recorded.

delete_model Not yet run
unverified (harvested, no recorded run)
allenai/olmes/oe_eval/utilities/model_utils.py
code served (permissive licence) · get_code("1325dacb19f6bd7e")
How it ran

no invocation recorded.

fix_optim_state_dict Not yet run
unverified (harvested, no recorded run)
allenai/olmo/olmo/optim.py
code served (permissive licence) · get_code("8c736d35652665c6")
How it ran

no invocation recorded.

maybe_nvtx_annotate Not yet run
unverified (harvested, no recorded run)
allenai/OLMo-core/src/olmo_core/_nvtx.py
code served (permissive licence) · get_code("b48e416f25d4cc2b")
How it ran

no invocation recorded.

normalize_mxfp8_scale_mode_value Not yet run
unverified (harvested, no recorded run)
allenai/OLMo-core/src/olmo_core/mxfp8_config.py
code served (permissive licence) · get_code("173adb946721713b")
How it ran

no invocation recorded.

Also present in other papers' code

Of 21 samples lifted from this paper's linked repositories, 21 carry a function identity and 0 do not. Of the 21 distinct functions with an identity, 6 are also present in other papers whose code we hold (5 with at least one paper dated earlier, 0 the same month, 6 later) and 15 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
causal_attention_bias 16 other papers
4 dated earlier, 12 later
2406.10670 (2024-06)
CoLoR-Filter: Conditional Loss Reduction Filtering for Targeted Language Model Pre-training
2409.17146 (2024-09)
Molmo and PixMo: Open Weights and Open Data for State-of-the-Art Vision-Language Models
2410.01380 (2024-10)
Knowledge Entropy Decay during Language Model Pretraining Hinders New Knowledge Acquisition
and 13 more not named here
fix_optim_state_dict 4 other papers
3 dated earlier, 1 later
2406.10670 (2024-06)
CoLoR-Filter: Conditional Loss Reduction Filtering for Targeted Language Model Pre-training
2410.01380 (2024-10)
Knowledge Entropy Decay during Language Model Pretraining Hinders New Knowledge Acquisition
2411.12925 (2024-11)
Loss-to-Loss Prediction: Scaling Laws for All Datasets
and 1 more not named here
decode_key 2 other papers
1 dated earlier, 1 later
2410.01380 (2024-10)
Knowledge Entropy Decay during Language Model Pretraining Hinders New Knowledge Acquisition
2602.11543 (2026-02)
Pretraining A Large Language Model using Distributed GPUs: A Memory-Efficient Decentralized Paradigm
encode_key 2 other papers
1 dated earlier, 1 later
2410.01380 (2024-10)
Knowledge Entropy Decay during Language Model Pretraining Hinders New Knowledge Acquisition
2602.11543 (2026-02)
Pretraining A Large Language Model using Distributed GPUs: A Memory-Efficient Decentralized Paradigm
flatten_dict 2 other papers
1 dated earlier, 1 later
2410.01380 (2024-10)
Knowledge Entropy Decay during Language Model Pretraining Hinders New Knowledge Acquisition
2602.11543 (2026-02)
Pretraining A Large Language Model using Distributed GPUs: A Memory-Efficient Decentralized Paradigm
longest_common_prefix 2 other papers
2 later
2604.21215 (2026-04)
The Recurrent Transformer: Greater Effective Depth and Efficient Decoding
2605.22297 (2026-05)
One LR Doesn't Fit All: Heavy-Tail Guided Layerwise Learning Rates for LLMs

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We present OLMo 2, the next generation of our fully open language models. OLMo 2 includes a family of dense autoregressive language models at 7B, 13B and 32B scales with fully released artifacts -- model weights, full training data, training code and recipes, training logs and thousands of intermediate checkpoints. In this work, we describe our modified model architecture and training recipe, focusing on techniques for achieving better training stability and improved per-token efficiency. Our updated pretraining data mixture introduces a new, specialized data mix called Dolmino Mix 1124, which significantly improves model capabilities across many downstream task benchmarks when introduced via late-stage curriculum training (i.e. specialized data during the annealing phase of pretraining). Finally, we incorporate best practices from Tülu 3 to develop OLMo 2-Instruct, focusing on permissive data and extending our final-stage reinforcement learning with verifiable rewards (RLVR). Our OLMo 2 base models sit at the Pareto frontier of performance to training compute, often matching or outperforming open-weight only models like Llama 3.1, Qwen 2.5, and Gemma 2 while using fewer FLOPs and with fully transparent training data, code, and recipe. Our fully open OLMo 2-Instruct models are competitive with open-weight only models of comparable size and even some proprietary models like GPT-3.5 Turbo and GPT 4o Mini.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2501.00656")
get_code_for_paper("2501.00656")
have("2501.00656")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2501.00656.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2501.00656.svg)](https://syntology.ai/paper/2501.00656)

Connect an agent — have() is free.