SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2202.00666 · 2022

Locally Typical Sampling

arXiv · PDF · Open in the Atlas

Code that ran

19 of 25 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; 3 honoured the contract we drafted, 1 violated it and 10 have no contract verdict; 5 failures of our instrument; 6 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/2202.00666.json · badge: /api/ran/2202.00666.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
cimeister/typical-sampling canonical (classifier label)
classifier basis not recorded on the link
10 ran · 5 no recorded run
HomebrewNLP/HomebrewNLP-Jax community (classifier label)
classifier basis not recorded on the link
9 ran · 1 no recorded run
FunctionStatusWhere it lives
add_sq Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/backend.py
code served (permissive licence) · get_code("29095fa631853bbe")
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 torch
import torch.nn as nn

torch.manual_seed(0)

# Analyzing the function:
# - Takes a single parameter 'name' of type str
# - Returns a str
# - Uses string methods: endswith(), slicing, concatenation
# - No complex objects needed, just strings

ARGS = {
    'name': 'test_stacked'
}
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 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
check_number_comma Ran
ran, violated the contract we drafted
cimeister/typical-sampling/src/transformers/convert_slow_tokenizer.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from UW-Madison-Lee-Lab/looped-tf, is pointer only (licence: NONE) · get_code("a727df5fd2f5599a")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

ensure_valid_input Ran
ran; our contract draft was wrong, not the code
cimeister/typical-sampling/src/transformers/convert_graph_to_onnx.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from UW-Madison-Lee-Lab/looped-tf, is pointer only (licence: NONE) · get_code("d770e1dd1d799a47")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

fn_if_dataclass Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/context.py
code served (permissive licence) · get_code("58bc40af1d90b395")
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 TestDataClass. 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
from typing import Any, Callable, Union, Dict, Optional, List

torch.manual_seed(0)

class DataClass:
    def serialize(self):
        return serialize(self)

def serialize(instance: Union[DataClass, Dict[str, Any]]):
    if isinstance(instance, DataClass):
        attributes = {key: getattr(instance, key) for key in dir(instance) if not key.startswith('_') and (not key.endswith('_'))}
        return serialize({key: value for key, value in attributes.items() if not isinstance(value, Callable)})
    if isinstance(instance, (list, tuple)):
        return [fn_if_dataclass(itm, serialize) for itm in instance]
    if isinstance(instance, dict):
        return {k: fn_if_dataclass(v, serialize) for k, v in instance.items()}
    return instance

def fn_if_dataclass(instance: Any, fn: Callable):
    return fn(instance) if isinstance(instance, (DataClass, list, tuple, dict)) else instance

# Create test instances
class TestDataClass(DataClass):
    def __init__(self):
        self.value = 42
        self.name = "test"
        self.data = torch.randn(2, 4)

test_instance = TestDataClass()
test_function = serialize

ARGS = {
    "instance": test_instance,
    "fn": 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 TestDataClass — a TestDataClass output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a TestDataClass 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
frame_encoder Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/script/quantized_vid2tfrecord.py
code served (permissive licence) · get_code("5c302780d36773f7")
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 bytes. 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 tensorflow as tf

# frame_encoder expects a 'frame' parameter which is passed to 
# tf.train.Int64List(value=frame)
# This means frame should be an iterable of integers

frame = [1, 2, 3, 4, 5]

ARGS = {
    'frame': frame
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bytes — a bytes output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a bytes 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
gelu_fast Ran
ran; our contract draft was wrong, not the code
cimeister/typical-sampling/src/transformers/activations.py
pointer only (licence: Apache-2.0) · get_code("a4475703ff58ecf9")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

gelu_fast Ran
ran, honoured the contract we drafted
cimeister/typical-sampling/src/transformers/activations_tf.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from VITA-Group/READ-ME, is pointer only (licence: NONE) · get_code("37a5eed2dbd663ca")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

gelu_new Ran
ran; our contract draft was wrong, not the code
cimeister/typical-sampling/src/transformers/activations.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from astro-jon/LCWL, is pointer only (licence: NONE) · get_code("45bb87451230d5e8")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

gelu_python Ran
ran; our contract draft was wrong, not the code
cimeister/typical-sampling/src/transformers/activations.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from astro-jon/LCWL, is pointer only (licence: NONE) · get_code("95f27ee4e1e8c5d3")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

generate_identified_filename Ran
ran; our contract draft was wrong, not the code
cimeister/typical-sampling/src/transformers/convert_graph_to_onnx.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from UW-Madison-Lee-Lab/looped-tf, is pointer only (licence: NONE) · get_code("7efe3db5c9e2f94d")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

get_abs_min_max Ran
ran on a synthesized input
cimeister/typical-sampling/src/transformers/debug_utils.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from parovicm/BADX, is pointer only (licence: Apache-2.0) · get_code("b5db92a796ef38f1")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

init_class_copy Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/context.py
code served (permissive licence) · get_code("5fbd4f093295aa97")
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 SimpleDataClass. 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 copy
from typing import Any, Callable, Union, Dict, Optional, List

class DataClass:
    def serialize(self):
        return serialize(self)

def fn_if_dataclass(instance: Any, fn: Callable):
    return fn(instance) if isinstance(instance, (DataClass, list, tuple, dict)) else instance

def serialize(instance: Union[DataClass, Dict[str, Any]]):
    if isinstance(instance, DataClass):
        attributes = {key: getattr(instance, key) for key in dir(instance) if not key.startswith('_') and (not key.endswith('_'))}
        return serialize({key: value for key, value in attributes.items() if not isinstance(value, Callable)})
    if isinstance(instance, (list, tuple)):
        return [fn_if_dataclass(itm, serialize) for itm in instance]
    if isinstance(instance, dict):
        return {k: fn_if_dataclass(v, serialize) for k, v in instance.items()}
    return instance

def init_class(instance: DataClass, config: Dict[str, Any]):
    for name in dir(instance):
        if name.startswith('_') or name.endswith('_') or name not in config:
            continue
        attr = getattr(instance, name)
        is_dataclass = isinstance(attr, DataClass)
        is_list = isinstance(attr, (list, tuple))
        is_dict = isinstance(attr, dict)
        if not (is_dataclass or (is_list and isinstance(attr[0], DataClass)) or (is_dict and isinstance(next(iter(attr.values())), DataClass))):
            setattr(instance, name, config[name])
            continue
        if is_dataclass:
            init_class(attr, config[name])
        elif is_list:
            setattr(instance, name, type(attr)((init_class_copy(attr[0], item) for item in config[name])))
        elif is_dict:
            base = next(iter(attr.values()))
            setattr(instance, name, {key: init_class_copy(base, item) for key, item in config[name].items()})
        else:
            raise ValueError(f'Unknown type {type(attr)} with given data {config[name]}')

def init_class_copy(instance: DataClass, config: Dict[str, Any]) -> DataClass:
    instance = copy.deepcopy(instance)
    init_class(instance, config)
    return instance

class SimpleDataClass(DataClass):
    def __init__(self):
        self.value = 10
        self.name = "test"
        self.nested = None
        self.items = []
        self.mapping = {}

class NestedDataClass(DataClass):
    def __init__(self):
        self.count = 5

nested_obj = NestedDataClass()
base_instance = SimpleDataClass()
base_instance.nested = nested_obj
base_instance.items = [NestedDataClass() for _ in range(2)]
base_instance.mapping = {"a": NestedDataClass(), "b": NestedDataClass()}

config = {
    "value": 20,
    "name": "updated",
    "nested": {
        "count": 15
    },
    "items": [
        {"count": 7},
        {"count": 9}
    ],
    "mapping": {
        "a": {"count": 11},
        "b": {"count": 13}
    }
}

ARGS = {
    "instance": base_instance,
    "config": config
}
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 SimpleDataClass — a SimpleDataClass output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDataClass 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
mish Ran
ran, honoured the contract we drafted
cimeister/typical-sampling/src/transformers/activations_tf.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from VITA-Group/READ-ME, is pointer only (licence: NONE) · get_code("cc8c8c3ebf0c343f")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

one_hot Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/inference.py
code served (permissive licence) · get_code("e11d769ad67f0934")
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 ArrayImpl, ndim 3, dtype family float, shape (2, 3, 3) 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 jax
from jax import numpy as jnp
import jax.random as jrandom

# Create a simple integer array input
inp = jnp.array([[0, 1, 2], [1, 2, 0]])

# Define the size parameter - number of classes for one-hot encoding
size = 3

# Construct the arguments dictionary
ARGS = {
    "inp": inp,
    "size": size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 3, dtype family float, shape (2, 3, 3) — shape (2, 3, 3) 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
promote_to Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/backend.py
code served (permissive licence) · get_code("f7c85a0d6b11bf74")
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 ArrayImpl, ndim 1, dtype family float, shape (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 jax
from jax import numpy as jnp
import numpy as np

# Create a small input array
inp = jnp.array([1.0, 2.0, 3.0, 4.0], dtype=jnp.float32)

# Create a target dtype
dtype = jnp.float64

ARGS = {
    "inp": inp,
    "dtype": dtype,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (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
quick_gelu Ran
ran, honoured the contract we drafted
cimeister/typical-sampling/src/transformers/activations_tf.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from VITA-Group/READ-ME, is pointer only (licence: NONE) · get_code("e2d56cb91f999bef")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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.

serialize Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/context.py
code served (permissive licence) · get_code("417d7c14445e03e0")
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 SimpleDataClass. 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 numpy as np
from typing import Any, Callable, Union, Dict, Optional, List

torch.manual_seed(0)

class DataClass:
    def serialize(self):
        return serialize(self)

def fn_if_dataclass(instance: Any, fn: Callable):
    return fn(instance) if isinstance(instance, (DataClass, list, tuple, dict)) else instance

def serialize(instance: Union[DataClass, Dict[str, Any]]):
    if isinstance(instance, DataClass):
        attributes = {key: getattr(instance, key) for key in dir(instance) if not key.startswith('_') and (not key.endswith('_'))}
        return serialize({key: value for key, value in attributes.items() if not isinstance(value, Callable)})
    if isinstance(instance, (list, tuple)):
        return [fn_if_dataclass(itm, serialize) for itm in instance]
    if isinstance(instance, dict):
        return {k: fn_if_dataclass(v, serialize) for k, v in instance.items()}
    return instance

# Test case 1: DataClass instance
class SimpleDataClass(DataClass):
    def __init__(self):
        self.value = 42
        self.name = "test"
        self.tensor = torch.randn(2, 4)

# Test case 2: Dict instance
test_dict = {
    "key1": 10,
    "key2": "value",
    "nested": {
        "inner_key": 3.14,
        "inner_value": torch.randn(2, 4)
    }
}

# Test case 3: List with mixed types
test_list = [
    42,
    "string",
    torch.randn(2, 4),
    {"dict_in_list": 99},
    SimpleDataClass()
]

# Test case 4: Tuple
test_tuple = (1, 2, "three", torch.randn(2, 4))

# Test case 5: Primitive
test_primitive = 100

# Use one of these as the main test instance
instance_to_serialize = SimpleDataClass()

ARGS = {
    "instance": instance_to_serialize
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SimpleDataClass — a SimpleDataClass output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDataClass 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
square_grad Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/src/backend.py
code served (permissive licence) · get_code("de13583a2c04b400")
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 ArrayImpl, 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 jax
import jax.numpy as jnp
from jax import random

# Define a simple callable function that takes two jax arrays and returns one
def simple_fn(x: jax.Array, wgt: jax.Array) -> jax.Array:
    """Simple function that multiplies and sums inputs"""
    return jnp.sum(x * wgt)

# Create small jax arrays
key = random.PRNGKey(0)

# src: input array (batch=2, dim=4)
src = jnp.ones((2, 4), dtype=jnp.float32)

# weight: weight array (dim=4,)
weight = jnp.ones((4,), dtype=jnp.float32)

# weight_sq: weight squared array (dim=4,)
weight_sq = jnp.ones((4,), dtype=jnp.float32)

ARGS = {
    "fn": simple_fn,
    "src": src,
    "weight": weight,
    "weight_sq": weight_sq,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, 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
try_except Ran
ran on a synthesized input
HomebrewNLP/HomebrewNLP-Jax/script/quantized_vid2tfrecord.py
code served (permissive licence) · get_code("0a4d744fe302fd21")
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 typing

torch.manual_seed(0)

# Create a simple function that may or may not raise an exception
def sample_fn(x, y=10):
    return x + y

# Create a function that raises an exception
def error_fn(x):
    raise ValueError("Test error")

# Create a function that takes no arguments
def no_arg_fn():
    return 42

ARGS = {
    "fn": sample_fn,
    "default": 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 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
convert_slow_tokenizer Not yet run
unverified (harvested, no recorded run)
cimeister/typical-sampling/src/transformers/convert_slow_tokenizer.py
pointer only (licence: Apache-2.0) · get_code("4e643fa0b277f39b")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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. No invocation recorded.

decoder Not yet run
unverified (harvested, no recorded run)
HomebrewNLP/HomebrewNLP-Jax/src/data.py
code served (permissive licence) · get_code("52eb8468051d0996")
How it ran

no invocation recorded.

deepspeed_reinit Not yet run
unverified (harvested, no recorded run)
cimeister/typical-sampling/src/transformers/deepspeed.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from bhargaviparanjape/robust-transformers, is pointer only (licence: Apache-2.0) · get_code("e187e5429b112df7")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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. No invocation recorded.

detect_overflow Not yet run
unverified (harvested, no recorded run)
cimeister/typical-sampling/src/transformers/debug_utils.py
pointer only (licence: Apache-2.0) · get_code("c551a79d5bb1b062")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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. No invocation recorded.

get_configuration_file Not yet run
unverified (harvested, no recorded run)
cimeister/typical-sampling/src/transformers/configuration_utils.py
pointer only (licence: Apache-2.0) · get_code("07e637f202f76ddb")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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. No invocation recorded.

infer_shapes Not yet run
unverified (harvested, no recorded run)
cimeister/typical-sampling/src/transformers/convert_graph_to_onnx.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from UW-Madison-Lee-Lab/looped-tf, is pointer only (licence: NONE) · get_code("3449d7d975edfb89")
How it ran

The body of this sample is withheld: Apache-2.0, as GitHub detects it on this paper's repository, cimeister/typical-sampling, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. 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. No invocation recorded.

Also present in other papers' code

Of 25 samples lifted from this paper's linked repositories, 25 carry a function identity and 0 do not. Of the 25 distinct functions with an identity, 15 are also present in other papers whose code we hold (13 with at least one paper dated earlier, 0 the same month, 15 later) and 10 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
mish 25 other papers
8 dated earlier, 16 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2104.08400 (2021-04)
Structure-Aware Abstractive Conversation Summarization via Discourse and Action Graphs
2106.00420 (2021-06)
Dialogue-oriented Pre-training
and 22 more not named here
gelu_new 24 other papers
10 dated earlier, 13 later, 1 same year, order not determinable
2004.10964 (2020-04)
Don't Stop Pretraining: Adapt Language Models to Domains and Tasks
2104.08066 (2021-04)
Effect of Visual Extensions on Natural Language Understanding in Vision-and-Language Models
2104.08400 (2021-04)
Structure-Aware Abstractive Conversation Summarization via Discourse and Action Graphs
and 21 more not named here
gelu_fast 22 other papers
10 dated earlier, 11 later, 1 same year, order not determinable
2010.03957 (2020-10)
Transformers for Modeling Physical Systems
2104.08066 (2021-04)
Effect of Visual Extensions on Natural Language Understanding in Vision-and-Language Models
2104.08400 (2021-04)
Structure-Aware Abstractive Conversation Summarization via Discourse and Action Graphs
and 19 more not named here
gelu_fast 19 other papers
3 dated earlier, 15 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2110.04366 (2021-10)
Towards a Unified View of Parameter-Efficient Transfer Learning
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 16 more not named here
quick_gelu 16 other papers
1 dated earlier, 15 later
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2211.05392 (2022-11)
EVENTS REALM: Event Reasoning of Entity States via Language Models
2212.00921 (2022-12)
AGRO: Adversarial Discovery of Error-prone groups for Robust Optimization
and 13 more not named here
ensure_valid_input 14 other papers
4 dated earlier, 9 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2107.00910 (2021-07)
Learned Token Pruning for Transformers
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 11 more not named here
generate_identified_filename 14 other papers
4 dated earlier, 9 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2107.00910 (2021-07)
Learned Token Pruning for Transformers
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 11 more not named here
infer_shapes 14 other papers
4 dated earlier, 9 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2107.00910 (2021-07)
Learned Token Pruning for Transformers
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 11 more not named here
check_number_comma 13 other papers
4 dated earlier, 8 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2107.00910 (2021-07)
Learned Token Pruning for Transformers
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 10 more not named here
convert_slow_tokenizer 13 other papers
4 dated earlier, 8 later, 1 same year, order not determinable
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2107.00910 (2021-07)
Learned Token Pruning for Transformers
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
and 10 more not named here
get_configuration_file 11 other papers
1 dated earlier, 10 later
2007.07779 (2020-07)
AdapterHub: A Framework for Adapting Transformers
2211.05392 (2022-11)
EVENTS REALM: Event Reasoning of Entity States via Language Models
2212.00921 (2022-12)
AGRO: Adversarial Discovery of Error-prone groups for Robust Optimization
and 8 more not named here
detect_overflow 4 other papers
1 dated earlier, 2 later, 1 same year, order not determinable
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
2022.naacl-main.130 (2022 (year only))
BAD-X: Bilingual Adapters Improve Zero-Shot Cross-Lingual Transfer
2212.00921 (2022-12)
AGRO: Adversarial Discovery of Error-prone groups for Robust Optimization
and 1 more not named here
get_abs_min_max 4 other papers
1 dated earlier, 2 later, 1 same year, order not determinable
2111.00160 (2021-11)
DSEE: Dually Sparsity-embedded Efficient Tuning of Pre-trained Language Models
2022.naacl-main.130 (2022 (year only))
BAD-X: Bilingual Adapters Improve Zero-Shot Cross-Lingual Transfer
2212.00921 (2022-12)
AGRO: Adversarial Discovery of Error-prone groups for Robust Optimization
and 1 more not named here
gelu_python 3 other papers
3 later
2211.02816 (2022-11)
PASTA: Table-Operations Aware Fact Verification via Sentence-Table Cloze Pre-training
2306.08891 (2023-06)
Interleaving Pre-Trained Language Models and Large Language Models for Zero-Shot NL2SQL Generation
2410.05748 (2024-10)
Label Confidence Weighted Learning for Target-level Sentence Simplification
deepspeed_reinit 1 other paper
1 later
2212.00921 (2022-12)
AGRO: Adversarial Discovery of Error-prone groups for Robust Optimization

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

Today's probabilistic language generators fall short when it comes to producing coherent and fluent text despite the fact that the underlying models perform well under standard metrics, e.g., perplexity. This discrepancy has puzzled the language generation community for the last few years. In this work, we posit that the abstraction of natural language generation as a discrete stochastic process--which allows for an information-theoretic analysis--can provide new insights into the behavior of probabilistic language generators, e.g., why high-probability texts can be dull or repetitive. Humans use language as a means of communicating information, aiming to do so in a simultaneously efficient and error-minimizing manner; in fact, psycholinguistics research suggests humans choose each word in a string with this subconscious goal in mind. We formally define the set of strings that meet this criterion: those for which each word has an information content close to the expected information content, i.e., the conditional entropy of our model. We then propose a simple and efficient procedure for enforcing this criterion when generating from probabilistic models, which we call locally typical sampling. Automatic and human evaluations show that, in comparison to nucleus and top-k sampling, locally typical sampling offers competitive performance (in both abstractive summarization and story generation) in terms of quality while consistently reducing degenerate repetitions.

For agents

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

get_harvested_code_for_paper("2202.00666")
get_code_for_paper("2202.00666")
have("2202.00666")

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

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

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

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

Connect an agent — have() is free.