SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1912.11554 · 2019

Composable Effects for Flexible and Accelerated Probabilistic Programming in NumPyro

arXiv · PDF · Open in the Atlas

Code that ran

23 of 26 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 22 have no contract verdict; 0 failures 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/1912.11554.json · badge: /api/ran/1912.11554.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
pyro-ppl/numpyro canonical (classifier label)
classifier basis: census
5 ran · 3 no recorded run
aleatory-science/numpyro community (classifier label)
classifier basis not recorded on the link
9 ran · 0 no recorded run
neurips2020submission7954/numpyro community (classifier label)
classifier basis not recorded on the link
9 ran · 0 no recorded run
FunctionStatusWhere it lives
apply_stack Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/primitives.py
code served (permissive licence) · get_code("f17cd8a35e3b7268")
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

# Define a minimal Messenger class that the stack expects
class Messenger:
    def process_message(self, msg):
        """Process a message before default handling"""
        pass
    
    def postprocess_message(self, msg):
        """Process a message after default handling"""
        pass

# Define a simple function to use as 'fn' in the message
def sample_fn(*args, sample_intermediates=False, **kwargs):
    if sample_intermediates:
        return torch.tensor([1.0, 2.0]), {'intermediate': 'data'}
    return torch.tensor([1.0, 2.0])

def deterministic_fn(*args, **kwargs):
    return torch.tensor([3.0, 4.0])

# Create a minimal message dict
msg = {
    'type': 'sample',
    'value': None,
    'fn': sample_fn,
    'args': (),
    'kwargs': {},
    'stop': False,
    'intermediates': None
}

# Create some simple messengers for the stack
messenger1 = Messenger()
messenger2 = Messenger()

# Set up the global stack
_PYRO_STACK = [messenger1, messenger2]

# Define the ARGS dictionary
ARGS = {
    'msg': msg
}
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
apply_stack Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/primitives.py
code served (permissive licence) · get_code("14286d43810b1d37")
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

torch.manual_seed(0)

# Define a minimal handler class that has process_message and postprocess_message methods
class MockHandler:
    def __init__(self, name="handler"):
        self.name = name
    
    def process_message(self, msg):
        # Handler can optionally set msg['stop'] to True to break early
        pass
    
    def postprocess_message(self, msg):
        # Handler processes message after value is set
        pass

# Define a minimal function that can be called as msg['fn']
def mock_sample_fn(*args, sample_intermediates=False, **kwargs):
    if sample_intermediates:
        return torch.randn(2, 4), None
    return torch.randn(2, 4)

def mock_deterministic_fn(*args, **kwargs):
    return torch.randn(2, 4)

# Set up the global _PYRO_STACK
_PYRO_STACK = [
    MockHandler("handler1"),
    MockHandler("handler2")
]

# Construct a valid message dict for a sample type
msg_sample = {
    'type': 'sample',
    'fn': mock_sample_fn,
    'args': (torch.randn(2, 4),),
    'kwargs': {},
    'value': None,
    'stop': False
}

ARGS = {
    'msg': msg_sample
}
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
autocorrelation Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("cb29f9477120556d")
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 ndarray, ndim 2, dtype family float, shape (4, 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 numpy as np

# Create a small test array with distinct dimensions
# Using shape (4, 3) to have distinguishable dimensions
x = np.random.randn(4, 3)

# axis parameter - valid axis for the input array
axis = 0

ARGS = {
    "x": x,
    "axis": axis,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (4, 3) — shape (4, 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
autocorrelation Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("9cd5cef89ff24afb")
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 ndarray, ndim 3, dtype family float, shape (2, 3, 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 numpy as onp

onp.random.seed(0)

# Create a small input array for testing
# Shape: (2, 3, 4) - batch=2, some_dim=3, sequence_length=4
x = onp.random.randn(2, 3, 4).astype(onp.float32)

ARGS = {
    "x": x,
    "axis": 0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
cond Ran
ran on a synthesized input
pyro-ppl/numpyro/numpyro/util.py
code served (permissive licence) · get_code("603fc5693fc0e73c")
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
import jax.numpy as jnp

# Define simple callable functions for true_fun and false_fun
def true_function(operand):
    """Function to execute when pred is True"""
    return operand * 2

def false_function(operand):
    """Function to execute when pred is False"""
    return operand + 1

# Create test operands - small JAX arrays
true_operand = jnp.array([1.0, 2.0, 3.0, 4.0])
false_operand = jnp.array([5.0, 6.0, 7.0, 8.0])

# Create a boolean predicate
pred = True

# Create the arguments dictionary
ARGS = {
    "pred": pred,
    "true_operand": true_operand,
    "true_fun": true_function,
    "false_operand": false_operand,
    "false_fun": false_function,
}
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 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
cond Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/util.py
code served (permissive licence) · get_code("e30672564474308b")
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
import jax.numpy as jnp

# Define simple functions that will be used as true_fun and false_fun
def true_function(operand):
    """Function to execute when predicate is True"""
    return operand * 2

def false_function(operand):
    """Function to execute when predicate is False"""
    return operand + 10

# Create small test operands
true_operand = jnp.array([1.0, 2.0, 3.0, 4.0])
false_operand = jnp.array([5.0, 6.0, 7.0, 8.0])

# Test with True predicate
pred = True

ARGS = {
    "pred": pred,
    "true_operand": true_operand,
    "true_fun": true_function,
    "false_operand": false_operand,
    "false_fun": false_function,
}
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 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
cond Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/util.py
code served (permissive licence) · get_code("c744d80fda3b6fa0")
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
import jax.numpy as jnp
from jax import device_put, jit, lax, ops, vmap

# Define simple functions to use as true_fun and false_fun
def true_branch(x):
    return x * 2

def false_branch(x):
    return x + 10

# Create simple operands (JAX arrays)
true_operand = jnp.array([1.0, 2.0, 3.0, 4.0])
false_operand = jnp.array([5.0, 6.0, 7.0, 8.0])

# Create a boolean predicate
pred = True

ARGS = {
    "pred": pred,
    "true_operand": true_operand,
    "true_fun": true_branch,
    "false_operand": false_operand,
    "false_fun": false_branch,
}
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 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
fori_loop Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/util.py
code served (permissive licence) · get_code("b382d69b4dcd640c")
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
import jax.numpy as jnp

def fori_loop(lower, upper, body_fun, init_val):
    _DISABLE_CONTROL_FLOW_PRIM = False
    if _DISABLE_CONTROL_FLOW_PRIM:
        val = init_val
        for i in range(int(lower), int(upper)):
            val = body_fun(i, val)
        return val
    else:
        return jax.lax.fori_loop(lower, upper, body_fun, init_val)

# Define body_fun: takes index and accumulator value, returns updated value
def body_fun(i, val):
    # Simple body that adds i to each element of the accumulator
    return val + i

# Define initial value as a JAX array
init_val = jnp.array([1.0, 2.0, 3.0, 4.0])

# Define loop bounds
lower = 0
upper = 5

ARGS = {
    "lower": lower,
    "upper": upper,
    "body_fun": body_fun,
    "init_val": init_val,
}
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 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
fori_loop Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/util.py
code served (permissive licence) · get_code("c79c82db04123255")
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 lax

# Define a simple body function that takes an index and a value, and returns updated value
def body_fun(i, val):
    """Simple body function that accumulates the index into the value."""
    return val + i

# Setup the arguments
lower = 0
upper = 5
init_val = jnp.array(0.0)

ARGS = {
    "lower": lower,
    "upper": upper,
    "body_fun": body_fun,
    "init_val": init_val,
}
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
gelman_rubin Ran
ran on a synthesized input
pyro-ppl/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("24d2161f7459a9d3")
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 ndarray, 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 numpy as np

# The function gelman_rubin expects:
# - x: NDArray with shape (C, N, ...) where C >= 2 (number of chains), N >= 2 (number of draws)
# - It computes variance statistics over chains and draws

# Create a small valid input array
# Shape: (C=3, N=4, feature_dim=2) 
# - 3 chains (C >= 2 requirement met)
# - 4 draws per chain (N >= 2 requirement met)
# - 2 features
np.random.seed(0)
x = np.random.randn(3, 4, 2).astype(np.float64)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, 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
gelman_rubin Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("446b9411492ba0b8")
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 ndarray, ndim 1, dtype family float, shape (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 numpy as np

np.random.seed(0)

# Create a valid input array for gelman_rubin
# Requirements:
# - ndim >= 2
# - shape[0] >= 2 (at least 2 chains)
# - shape[1] >= 2 (at least 2 draws per chain)
# Using shape (C=4, N=5, D=3) for chains, draws, and parameter dimensions
x = np.random.randn(4, 5, 3)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (3,) — shape (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
gelman_rubin Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("0844d828a7866d7b")
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 ndarray, 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 numpy as onp

# The function gelman_rubin expects:
# x: numpy.ndarray with ndim >= 2, shape[0] >= 2, shape[1] >= 2
# It computes statistics over chains (first dimension) and draws (second dimension)
# Additional dimensions are kept as-is for the output shape

# Create a sample input array
# Shape: (C=2 chains, N=3 draws, param_dim=4)
# This satisfies: ndim >= 2, shape[0] >= 2, shape[1] >= 2
x = onp.random.randn(2, 3, 4).astype(onp.float64)

ARGS = {
    "x": x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, 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
identity Ran
ran, honoured the contract we drafted
neurips2020submission7954/numpyro/numpyro/primitives.py
code served (permissive licence) · get_code("caeb28d34b34bc2a")
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) 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
import torch.nn as nn

torch.manual_seed(0)

# The identity function simply returns its first argument unchanged
# It accepts x as the first positional argument, then *args and **kwargs
# Since the function body just returns x, we need to provide valid inputs

# Create a simple tensor for x
x = torch.randn(2, 4)

# Create some additional positional arguments
args = (torch.randn(3, 5), "test_arg", 42)

# Create some keyword arguments
kwargs = {
    "key1": torch.randn(2, 3),
    "key2": "value",
    "key3": [1, 2, 3]
}

ARGS = {
    "x": x,
    "args": args,
    "kwargs": kwargs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
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
optax_to_numpyro Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/optim.py
code served (permissive licence) · get_code("34901ba809969a2a")
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 _NumPyroOptim. 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 optax
import jax
import jax.numpy as jnp
from typing import NamedTuple

# Create a simple pytree-structured parameter dict
params = {
    'w1': jnp.array([[1.0, 2.0, 3.0, 4.0],
                      [5.0, 6.0, 7.0, 8.0],
                      [9.0, 10.0, 11.0, 12.0]]),
    'b1': jnp.array([0.1, 0.2, 0.3, 0.4]),
    'w2': jnp.array([[1.0, 2.0],
                      [3.0, 4.0],
                      [5.0, 6.0],
                      [7.0, 8.0]])
}

# Create a simple optax GradientTransformation
# Using Adam optimizer as an example
transformation = optax.adam(learning_rate=0.01)

ARGS = {
    'transformation': transformation
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, optax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type _NumPyroOptim — a _NumPyroOptim output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a _NumPyroOptim 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
patch_dependency Ran
ran on a synthesized input
pyro-ppl/numpyro/numpyro/patch.py
code served (permissive licence) · get_code("5b4768efc8e097af")
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 sys
import types
from types import ModuleType

# Create a mock module structure for testing
mock_submodule = types.ModuleType('submodule')
mock_submodule.target_function = lambda x: x * 2

mock_root = types.ModuleType('mock_root')
mock_root.submodule = mock_submodule
mock_root.__name__ = 'mock_root'

ARGS = {
    'target': 'mock_root.submodule.target_function',
    'root_module': mock_root
}
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 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
patch_dependency Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/patch.py
code served (permissive licence) · get_code("ad4e520dfbb97626")
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 types

# Create a simple module structure for testing
root_module = types.ModuleType('test_module')
root_module.__name__ = 'test_module'

# Create a submodule
submodule = types.ModuleType('submodule')
setattr(root_module, 'submodule', submodule)

# Create a function to patch
def original_function(x):
    return x * 2

setattr(submodule, 'my_function', original_function)

# Define target as a dotted path to the function
target = 'test_module.submodule.my_function'

ARGS = {
    'target': target,
    'root_module': root_module
}
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
sample Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/primitives.py
code served (permissive licence) · get_code("cc05aa3302d07e64")
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 3, dtype family float, shape (2, 3, 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 numpy as np
from unittest.mock import Mock

torch.manual_seed(0)

# Define the global _PYRO_STACK that the function uses
_PYRO_STACK = []

# Create a mock handler class
class MockHandler:
    def process_message(self, msg):
        pass
    
    def postprocess_message(self, msg):
        pass

# Create a mock stochastic function that returns a sample
def mock_stochastic_fn(rng_key=None, sample_shape=()):
    """Mock function that simulates a stochastic function like a distribution."""
    if sample_shape:
        return torch.randn(*sample_shape, 4)
    return torch.randn(4)

# Define arguments for the sample function
ARGS = {
    'name': 'my_sample',
    'fn': mock_stochastic_fn,
    'obs': None,
    'rng_key': None,
    'sample_shape': (2, 3)
}
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 Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
split_gelman_rubin Ran
ran on a synthesized input
pyro-ppl/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("388ce51362d7e858")
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 ndarray, 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 numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create a small sample array for split_gelman_rubin
# Requirements:
# - x.ndim >= 2
# - x.shape[0] >= 2 (chains)
# - x.shape[1] >= 4 (draws, needed for split_gelman_rubin)
# Additional dimensions are allowed and will be treated as event dimensions

# Create shape (3, 8, 4) - 3 chains, 8 draws, 4-dimensional events
x = np.random.randn(3, 8, 4)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, 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
split_gelman_rubin Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("b8e722389fc0860a")
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 ndarray, ndim 1, dtype family float, shape (5,) 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 numpy as np

# Set seed for reproducibility
np.random.seed(0)

# Create a valid input array for split_gelman_rubin
# Requirements:
# - x.ndim >= 2
# - x.shape[0] >= 2 (chains)
# - x.shape[1] >= 4 (draws, needed for split_gelman_rubin)
# Create shape (3, 6, 5) - 3 chains, 6 draws, 5 parameters
x = np.random.randn(3, 6, 5)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (5,) — shape (5,) 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
split_gelman_rubin Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("4c89cb01a268cebb")
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 ndarray, ndim 1, dtype family float, shape (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 numpy as onp
import numpy as np

# The function split_gelman_rubin expects:
# - x: numpy.ndarray with ndim >= 2, shape[0] >= 2, shape[1] >= 4
# Let's create a small sample array with:
# - 4 chains (dimension 0, >= 2)
# - 8 draws (dimension 1, >= 4)
# - 3 parameters (additional dimensions)

np.random.seed(0)
x = np.random.randn(4, 8, 3).astype(np.float64)

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (3,) — shape (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
while_loop Ran
ran on a synthesized input
pyro-ppl/numpyro/numpyro/util.py
code served (permissive licence) · get_code("f3c8e08969a068a3")
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 jax
import jax.numpy as jnp
from typing import Any, Callable

# Set up JAX to use CPU
jax.config.update('jax_platform_name', 'cpu')

# Define condition function: continues while value < 10
def cond_fun(val: dict) -> bool:
    return val['counter'] < 10

# Define body function: increments counter and accumulates sum
def body_fun(val: dict) -> dict:
    return {
        'counter': val['counter'] + 1,
        'sum': val['sum'] + val['counter']
    }

# Initialize value with counter and sum
init_val = {
    'counter': 0,
    'sum': jnp.array(0.0)
}

ARGS = {
    'cond_fun': cond_fun,
    'body_fun': body_fun,
    'init_val': init_val
}
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 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
while_loop Ran
ran on a synthesized input
aleatory-science/numpyro/numpyro/util.py
code served (permissive licence) · get_code("fa4d540af0a1fb04")
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 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 jax.numpy as jnp

def cond_fun(val):
    """Condition: continue while val < 5"""
    return val < 5

def body_fun(val):
    """Body: increment val by 1"""
    return val + 1

init_val = jnp.array(0)

ARGS = {
    "cond_fun": cond_fun,
    "body_fun": body_fun,
    "init_val": init_val,
}
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 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
while_loop Ran
ran on a synthesized input
neurips2020submission7954/numpyro/numpyro/util.py
code served (permissive licence) · get_code("6ccdb50f357e8810")
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 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 jax
import jax.numpy as jnp
from jax import lax

def cond_fun(val):
    """Condition function: continue while val < 10"""
    return val < 10

def body_fun(val):
    """Body function: increment val by 1"""
    return val + 1

init_val = jnp.array(0)

ARGS = {
    "cond_fun": cond_fun,
    "body_fun": body_fun,
    "init_val": init_val,
}
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 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
autocorrelation Not yet run
unverified (harvested, no recorded run)
pyro-ppl/numpyro/numpyro/diagnostics.py
code served (permissive licence) · get_code("cb53b94660b27609")
How it ran

no invocation recorded.

maybe_jit Not yet run
unverified (harvested, no recorded run)
pyro-ppl/numpyro/numpyro/util.py
code served (permissive licence) · get_code("829e93b903800797")
How it ran

no invocation recorded.

optax_to_numpyro Not yet run
unverified (harvested, no recorded run)
pyro-ppl/numpyro/numpyro/optim.py
code served (permissive licence) · get_code("15c9685e50664934")
How it ran

no invocation recorded.

Also present in other papers' code

Of 26 samples lifted from this paper's linked repositories, 26 carry a function identity and 0 do not. Of the 23 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 22 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
identity 5 other papers
5 later
2002.05202 (2020-02)
GLU Variants Improve Transformer
2003.05997 (2020-03)
Efficient Content-Based Sparse Attention with Routing Transformers
2006.04768 (2020-06)
Linformer: Self-Attention with Linear Complexity
and 2 more not named here

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

NumPyro is a lightweight library that provides an alternate NumPy backend to the Pyro probabilistic programming language with the same modeling interface, language primitives and effect handling abstractions. Effect handlers allow Pyro's modeling API to be extended to NumPyro despite its being built atop a fundamentally different JAX-based functional backend. In this work, we demonstrate the power of composing Pyro's effect handlers with the program transformations that enable hardware acceleration, automatic differentiation, and vectorization in JAX. In particular, NumPyro provides an iterative formulation of the No-U-Turn Sampler (NUTS) that can be end-to-end JIT compiled, yielding an implementation that is much faster than existing alternatives in both the small and large dataset regimes.

For agents

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

get_harvested_code_for_paper("1912.11554")
get_code_for_paper("1912.11554")
have("1912.11554")

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

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

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

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

Connect an agent — have() is free.