SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2001.00888 · 2020

Towards Scalable Dataframe Systems

arXiv · PDF · Open in the Atlas

Code that ran

8 of 8 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; 0 honoured the contract we drafted, 0 violated it and 5 have no contract verdict; 3 failures of our instrument; 0 no recorded run), measured 2026-11-21; 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/2001.00888.json · badge: /api/ran/2001.00888.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
modin-project/modin canonical (classifier label)
classifier basis: census
8 ran · 0 no recorded run
FunctionStatusWhere it lives
align_indents Ran
ran on a synthesized input
modin-project/modin/modin/utils.py
code served (permissive licence) · get_code("a7dabcec55a12674")
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 numpy as np
from textwrap import dedent, indent

# Analyze the function: align_indents takes two parameters: source (str) and target (str)
# The function computes indentation from source and applies it to target
# Both parameters are strings, so we need simple string examples

# Create test strings with different indentation levels
source_string = "    def example():\n        pass"  # 4 spaces base indent
target_string = "def foo():\n    return 42"  # will be dedented then re-indented

ARGS = {
    "source": source_string,
    "target": target_string,
}
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 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
append_to_docstring Ran
ran on a synthesized input
modin-project/modin/modin/utils.py
code served (permissive licence) · get_code("eb8913ef26a0ff70")
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
from textwrap import dedent, indent
from typing import Callable

def sample_func(x: int) -> int:
    """
    This is a sample function.
    
    It does something.
    """
    return x * 2

def sample_func_no_doc(x: int) -> int:
    return x * 3

message_to_append = """
    
    Additional information:
    This is extra documentation.
    More details here.
    """

ARGS = {
    "message": message_to_append
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas, 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
ensure_decoded Ran
ran on a synthesized input
modin-project/modin/modin/core/computation/common.py
code served (permissive licence) · get_code("dd44590ac8b3fee5")
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 numpy as np
from pandas._config import get_option

# Test with bytes input
test_bytes = b"hello"

# Test with numpy bytes input
test_np_bytes = np.bytes_("world")

# Test with regular string input
test_string = "already_a_string"

# Define ARGS - the function takes one parameter 's'
# We'll test with bytes since that's what the function is designed to handle
ARGS = {
    "s": b"test_string"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — 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
format_string Ran
ran on a synthesized input
modin-project/modin/modin/utils.py
code served (permissive licence) · get_code("61a21a16d96874db")
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 re
from textwrap import dedent, indent

# Construct valid arguments for format_string function

# The function takes a template string and keyword arguments
# It substitutes placeholders in the format {key} with proper indentation

template = """\
def hello():
    {greeting}
    {body}
"""

greeting = "print('Hello')"

body = """\
for i in range(3):
    print(i)"""

ARGS = {
    'template': template,
    'greeting': greeting,
    'body': body,
}
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
reconstruct_object Ran
ran on a synthesized input
modin-project/modin/modin/core/computation/align.py
code served (permissive licence) · get_code("638e97916d0e5aa4")
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 MinimalPandasObject. 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 numpy as np
from pandas.core.base import PandasObject
import pandas as pd

class MinimalPandasObject(PandasObject):
    """Minimal PandasObject subclass for testing"""
    def __init__(self, data, dtype=None, **kwargs):
        self.data = data
        self.dtype = dtype if dtype is not None else data.dtype

ARGS = {
    "typ": MinimalPandasObject,
    "obj": np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32),
    "axes": {"index": [0, 1], "columns": [0, 1, 2]},
    "dtype": np.float64,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MinimalPandasObject — a MinimalPandasObject output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinimalPandasObject 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
register_vcs_handler Ran
ran; our contract draft was wrong, not the code
modin-project/modin/modin/_version.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from DeepExperience/HyperEyes, is pointer only (licence: NONE) · get_code("45333e6d0a056314")
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 DeepExperience/HyperEyes, 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.

run_command Ran
ran; our contract draft was wrong, not the code
modin-project/modin/modin/_version.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from DeepExperience/HyperEyes, is pointer only (licence: NONE) · get_code("e36817d1c9cffe87")
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 DeepExperience/HyperEyes, 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.

versions_from_parentdir Ran
ran; our contract draft was wrong, not the code
modin-project/modin/modin/_version.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from DeepExperience/HyperEyes, is pointer only (licence: NONE) · get_code("74664b7fba1494f5")
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 DeepExperience/HyperEyes, 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.

Also present in other papers' code

Of 8 samples lifted from this paper's linked repositories, 8 carry a function identity and 0 do not. Of the 8 distinct functions with an identity, 3 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 3 later) and 5 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
register_vcs_handler 3 other papers
3 later
2307.15295 (2023-07)
Sensitivity of the IceCube Upgrade to Atmospheric Neutrino Oscillations
2604.11554 (2026-04)
Relax: An Asynchronous Reinforcement Learning Engine for Omni-Modal Post-Training at Scale
2605.07177 (2026-05)
HyperEyes: Dual-Grained Efficiency-Aware Reinforcement Learning for Parallel Multimodal Search Agents
run_command 3 other papers
3 later
2307.15295 (2023-07)
Sensitivity of the IceCube Upgrade to Atmospheric Neutrino Oscillations
2604.11554 (2026-04)
Relax: An Asynchronous Reinforcement Learning Engine for Omni-Modal Post-Training at Scale
2605.07177 (2026-05)
HyperEyes: Dual-Grained Efficiency-Aware Reinforcement Learning for Parallel Multimodal Search Agents
versions_from_parentdir 3 other papers
3 later
2307.15295 (2023-07)
Sensitivity of the IceCube Upgrade to Atmospheric Neutrino Oscillations
2604.11554 (2026-04)
Relax: An Asynchronous Reinforcement Learning Engine for Omni-Modal Post-Training at Scale
2605.07177 (2026-05)
HyperEyes: Dual-Grained Efficiency-Aware Reinforcement Learning for Parallel Multimodal Search Agents

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-21.

Repositories linked to this paper

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

Abstract

Dataframes are a popular abstraction to represent, prepare, and analyze data. Despite the remarkable success of dataframe libraries in Rand Python, dataframes face performance issues even on moderately large datasets. Moreover, there is significant ambiguity regarding dataframe semantics. In this paper we lay out a vision and roadmap for scalable dataframe systems. To demonstrate the potential in this area, we report on our experience building MODIN, a scaled-up implementation of the most widely-used and complex dataframe API today, Python's pandas. With pandas as a reference, we propose a simple data model and algebra for dataframes to ground discussion in the field. Given this foundation, we lay out an agenda of open research opportunities where the distinct features of dataframes will require extending the state of the art in many dimensions of data management. We discuss the implications of signature data-frame features including flexible schemas, ordering, row/column equivalence, and data/metadata fluidity, as well as the piecemeal, trial-and-error-based approach to interacting with dataframes.

For agents

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

get_harvested_code_for_paper("2001.00888")
get_code_for_paper("2001.00888")
have("2001.00888")

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

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

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

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

Connect an agent — have() is free.