SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2112.06351 · 2021

Neural Point Process for Learning Spatiotemporal Event Dynamics

arXiv · PDF · Open in the Atlas

Code that ran

12 of 15 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 11 have no contract verdict; 1 failure of our instrument; 3 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/2112.06351.json · badge: /api/ran/2112.06351.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
rose-stl-lab/deepstpp canonical (classifier label)
classifier basis not recorded on the link
12 ran · 3 no recorded run
FunctionStatusWhere it lives
color_list Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/rose.py
code served (permissive licence) · get_code("3879d0197c71a80a")
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 list. 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

torch.manual_seed(0)

# The function color_list expects a list of color tuples
# Each color is a tuple of (r, g, b) values in the range 0-255
colors = [
    (255, 0, 0),      # Red
    (0, 255, 0),      # Green
    (0, 0, 255),      # Blue
    (255, 255, 0),    # Yellow
]

ARGS = {
    "colors": colors
}
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 list — a list output has no array shape of its own; none is 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
eval_loss Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/util.py
code served (permissive licence) · get_code("112e3dec2560257d")
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 tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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)

class DummyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def loss(self, st_x, st_y):
        # Model expects st_x and st_y tensors
        # Returns (loss, sll, tll) where each is a tensor
        output = self.linear(st_x)
        loss = torch.tensor(0.5)
        sll = torch.randn(2)
        tll = torch.randn(2)
        return loss, sll, tll

model = DummyModel()

test_loader = [
    (torch.randn(2, 4), torch.randn(2, 3), None, None, None),
    (torch.randn(2, 4), torch.randn(2, 3), None, None, None),
]

device = 'cpu'

ARGS = {
    'model': model,
    'test_loader': test_loader,
    'device': device
}
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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
eval_loss_rmtpp Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/util.py
code served (permissive licence) · get_code("6c684fad1c279e86")
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 float, 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)

class DummyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def loss(self, x, y):
        # Simple dummy loss computation
        output = self.linear(x)
        return nn.functional.mse_loss(output, y)

# Create model
model = DummyModel()

# Create test loader as list of tuples
# Each tuple contains (st_x, st_y, _, _, _)
# st_x and st_y are tensors, other 3 elements are placeholders
test_loader = [
    (torch.randn(2, 4), torch.randn(2, 3), None, None, None),
    (torch.randn(2, 4), torch.randn(2, 3), None, None, None),
]

# Device
device = 'cpu'

ARGS = {
    'model': model,
    'test_loader': test_loader,
    'device': device,
}
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 float, 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
frame_args Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/plotter.py
code served (permissive licence) · get_code("53e7660ce69e4190")
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 numpy as np

torch.manual_seed(0)

# Analyze the function:
# frame_args(duration) takes a single parameter 'duration'
# It returns a dict with 'frame', 'mode', 'fromcurrent', and 'transition' keys
# The duration parameter is used as a value in the returned dict
# No complex usage patterns - just needs to be a value that can be assigned

# duration can be a number (int or float)
duration = 0.5

ARGS = {
    'duration': duration
}
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 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
inverse_transform Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/plotter.py
code served (permissive licence) · get_code("c89b6ce704552e08")
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 tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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 sklearn.preprocessing import StandardScaler

# Create a scaler that can perform inverse_transform
# The function expects a scaler with inverse_transform method
scaler = StandardScaler()

# Fit the scaler with sample data of shape (n_samples, 3)
# This is necessary before calling inverse_transform
sample_data = np.array([
    [1.0, 2.0, 3.0],
    [2.0, 3.0, 4.0],
    [3.0, 4.0, 5.0],
    [4.0, 5.0, 6.0]
])
scaler.fit(sample_data)

# Create small ranges for each dimension
x_range = np.array([1.5, 2.5])
y_range = np.array([3.5, 4.5])
t_range = np.array([5.5, 6.5])

ARGS = {
    'x_range': x_range,
    'y_range': y_range,
    't_range': t_range,
    'scaler': scaler
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
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
kl_normal Ran
ran; our contract draft was wrong, not the code
rose-stl-lab/deepstpp/src/model.py
code served (permissive licence) · get_code("32a0293ea08ef89b")
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 1, dtype family float, shape (2,) 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)

batch_size = 2
dim = 4

qm = torch.randn(batch_size, dim)
qv = torch.abs(torch.randn(batch_size, dim)) + 0.1
pm = torch.randn(batch_size, dim)
pv = torch.abs(torch.randn(batch_size, dim)) + 0.1

ARGS = {
    "qm": qm,
    "qv": qv,
    "pm": pm,
    "pv": pv,
}
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 1, dtype family float, shape (2,) — shape (2,) 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
log_ft Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/rmtpp.py
code served (permissive licence) · get_code("4189b8f5d0a4f106")
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)

# Construct small tensors for the function parameters
# The function performs element-wise operations on vh, w, b, t
# All should be broadcastable tensors

vh = torch.randn(2, 4)
w = torch.randn(2, 4)
b = torch.randn(2, 4)
t = torch.randn(2, 4)

ARGS = {
    "vh": vh,
    "w": w,
    "b": b,
    "t": t
}
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
make_colormap Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/rose.py
code served (permissive licence) · get_code("50dc858e2ea62661")
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 LinearSegmentedColormap. 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 matplotlib.colors as mcolors

# Analyze the function: make_colormap takes a sequence (seq) parameter
# The sequence should contain floats in (0,1) and RGB-tuples (3-tuples of floats)
# The function interleaves floats and RGB tuples to build a colormap

# Construct a valid sequence with floats and RGB-tuples
seq = [
    (1.0, 0.0, 0.0),  # Red RGB tuple
    0.25,               # Float in (0, 1)
    (0.0, 1.0, 0.0),  # Green RGB tuple
    0.5,                # Float in (0, 1)
    (0.0, 0.0, 1.0),  # Blue RGB tuple
    0.75,               # Float in (0, 1)
    (1.0, 1.0, 0.0),  # Yellow RGB tuple
]

ARGS = {
    'seq': seq
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LinearSegmentedColormap — a LinearSegmentedColormap output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LinearSegmentedColormap 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
normalize_color Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/rose.py
code served (permissive licence) · get_code("4c563dbfea1e3057")
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 tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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)

# The function normalize_color takes a color tuple/list with r, g, b values
# and normalizes them by dividing by 255.0
# We need to provide a valid color argument with three numeric values

color = (255, 128, 64)

ARGS = {
    "color": color
}
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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
sample_gaussian Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/model.py
code served (permissive licence) · get_code("41dcba471efe8ce7")
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)

# Construct small tensors for mean and variance
batch_size = 2
feature_dim = 4

m = torch.randn(batch_size, feature_dim)
v = torch.abs(torch.randn(batch_size, feature_dim)) + 0.1  # Ensure positive variance

ARGS = {
    "m": m,
    "v": v,
}
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
subsequent_mask Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/model.py
code served (permissive licence) · get_code("832dca1c75b90b78")
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 (4, 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)

# The function takes a single parameter 'sz' which is an integer
# representing the size of the square mask to create
# Looking at the function body:
# - torch.triu(torch.ones(sz, sz)) creates an upper triangular matrix
# - The result is transposed and masked with -inf and 0.0 values
# So 'sz' should be a positive integer representing matrix dimension

ARGS = {
    "sz": 4
}
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 (4, 4) — shape (4, 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
t_intensity Ran
ran on a synthesized input
rose-stl-lab/deepstpp/src/rmtpp.py
code served (permissive licence) · get_code("62e257e55237d22e")
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)

# vh: appears to be a tensor that will be added to w * t + b
# The function computes exp(vh + w * t + b), so these should be compatible shapes
# w: a scalar or tensor that multiplies t
# b: a scalar or tensor bias term
# t: a scalar or tensor time parameter

vh = torch.randn(2, 4)
w = torch.randn(1)
b = torch.randn(1)
t = torch.randn(1)

ARGS = {
    "vh": vh,
    "w": w,
    "b": b,
    "t": t
}
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
calc_lamb Not yet run
unverified (harvested, no recorded run)
rose-stl-lab/deepstpp/src/rmtpp.py
code served (permissive licence) · get_code("887cdcc5421f9a0e")
How it ran

no invocation recorded.

plot_lambst_static Not yet run
unverified (harvested, no recorded run)
rose-stl-lab/deepstpp/src/plotter.py
code served (permissive licence) · get_code("d0599562263a6c07")
How it ran

no invocation recorded.

train_rmtpp Not yet run
unverified (harvested, no recorded run)
rose-stl-lab/deepstpp/src/util.py
code served (permissive licence) · get_code("64a769b7ade35914")
How it ran

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 1 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 1 later) and 14 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
kl_normal 1 other paper
1 later
2307.07947 (2023-07)
Language Conditioned Traffic Generation

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

Learning the dynamics of spatiotemporal events is a fundamental problem. Neural point processes enhance the expressivity of point process models with deep neural networks. However, most existing methods only consider temporal dynamics without spatial modeling. We propose Deep Spatiotemporal Point Process (\ours{}), a deep dynamics model that integrates spatiotemporal point processes. Our method is flexible, efficient, and can accurately forecast irregularly sampled events over space and time. The key construction of our approach is the nonparametric space-time intensity function, governed by a latent process. The intensity function enjoys closed form integration for the density. The latent process captures the uncertainty of the event sequence. We use amortized variational inference to infer the latent process with deep networks. Using synthetic datasets, we validate our model can accurately learn the true intensity function. On real-world benchmark datasets, our model demonstrates superior performance over state-of-the-art baselines. Our code and data can be found at the https://github.com/Rose-STL-Lab/DeepSTPP.

For agents

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

get_harvested_code_for_paper("2112.06351")
get_code_for_paper("2112.06351")
have("2112.06351")

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

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

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

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

Connect an agent — have() is free.