| IAT |
Ran ran on a synthesized input |
s-ilic/ECLAIR/ECLAIR_plots.py code served (permissive licence) · get_code("8573d37bba03679c") How it ranRan 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 float64, ndim 0, 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 scipy.fft import fft, ifft
# Create sample data
# The function takes samples and reshapes it to 1D
# It performs FFT operations on it
# samples.T.reshape(-1, order='C') suggests samples should be array-like
# Create a simple 2D array to test
samples = np.array([
[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]
])
# Define the ARGS dictionary
ARGS = {
'samples': samples,
'c': 5.0,
'norm': True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| SC |
Ran ran on a synthesized input |
s-ilic/ECLAIR/ECLAIR_plots.py code served (permissive licence) · get_code("ab9e5bdaa767ed2f") How it ranRan 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, 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 numpy as np
# SC function expects:
# - samples: array-like that can be flattened
# - X: numeric value (percentage)
# Create sample data
samples = np.array([[1.5, 2.3, 3.1, 4.2],
[5.0, 6.1, 7.2, 8.3]])
X = 25.0
ARGS = {
"samples": samples,
"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 list, ndim 1, dtype family float — a list 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
|
| SG |
Ran ran on a synthesized input |
s-ilic/ECLAIR/likelihoods/CMB/Planck/PR4/hillipop_EE/tools.py code served (permissive licence) · get_code("7ffc9e2d1e4092d9") How it ranRan 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 (10,) 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
# Construct arguments for SG function
# Parameters: l, cl, nsm=5, lcut=0
# l: appears to be unused in the function body, but we need to provide it
l = None # or could be any value since it's not used
# cl: a numpy array that gets copied and smoothed with gaussian_filter1d
# Should be 1D based on usage with nd.gaussian_filter1d
cl = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
# nsm: sigma for gaussian filter (default 5)
nsm = 5
# lcut: cutoff index (default 0)
lcut = 0
ARGS = {
"l": l,
"cl": cl,
"nsm": nsm,
"lcut": lcut
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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 (10,) — shape (10,) 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
|
| SQ |
Ran ran on a synthesized input |
s-ilic/ECLAIR/ECLAIR_plots.py code served (permissive licence) · get_code("edf74ef28a8bc1ac") How it ranRan 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, 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 numpy as np
import torch
torch.manual_seed(0)
# The function SQ takes:
# - samples: needs to be flattenable (numpy array or torch tensor)
# - X: a number representing a percentage
# The function flattens samples and computes quantiles at (100-X)/2/100 and 1-(100-X)/2/100
# Create sample data - a simple numpy array
samples = np.array([[1.2, 3.4, 5.6, 7.8],
[2.1, 4.3, 6.5, 8.9]])
# X is a percentage value (e.g., 95 for 95% confidence interval)
X = 95
ARGS = {
"samples": samples,
"X": X
}
- 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 list, ndim 1, dtype family float — a list 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
|
| append_outlier_dist_info |
Ran ran on a synthesized input |
astromedia/mcmc-analysis/utilities_mcmc_analysis.py pointer only (licence: MIT) · get_code("70b45fa4c782090f") How it ranThe body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, astromedia/mcmc-analysis, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| auto_window |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/autocorr.py code served (permissive licence) · get_code("5574559b8d4c0099") How it ranRan 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 int64, 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 numpy as np
# Construct valid arguments for auto_window function
# The function takes:
# - taus: an array-like object that supports len() and comparison operations
# - c: a scalar value used in the comparison
# Create a small array of tau values (decay constants or time constants)
taus = np.array([0.1, 0.5, 1.0, 2.0, 5.0])
# Create a scalar c value for the window calculation
c = 0.7
ARGS = {
"taus": taus,
"c": c
}
- 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 int64, 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
|
| convert_to_stdev |
Ran ran on a synthesized input |
s-ilic/ECLAIR/likelihoods/CMB/Planck/PR4/hillipop_EE/tools.py code served (permissive licence) · get_code("9982aa84edbe1110") How it ranRan 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
np.random.seed(0)
# Create a small 2D grid of likelihood values
sigma = np.random.rand(4, 3)
ARGS = {
"sigma": sigma
}
- 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
|
| default_beta_ladder |
Ran ran on a synthesized input |
mcfit/emcee/emcee/ptsampler.py code served (permissive licence) · get_code("42abc12a6b99da3d") How it ranRan 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 (10,) 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
# Construct ARGS for default_beta_ladder
ARGS = {
'ndim': 5,
'ntemps': 10,
'Tmax': None
}
- 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 (10,) — shape (10,) 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
|
| deprecated |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/utils.py code served (permissive licence) · get_code("87b482abfc07970e") How it ranRan 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 warnings
from functools import wraps
def deprecation_warning(msg):
warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
def deprecated(alternate):
def wrapper(func, alternate=alternate):
msg = "'{0}' is deprecated.".format(func.__name__)
if alternate is not None:
msg += " Use '{0}' instead.".format(alternate)
@wraps(func)
def f(*args, **kwargs):
deprecation_warning(msg)
return func(*args, **kwargs)
return f
return wrapper
# Test function to decorate
def old_function(x, y):
"""An old function that is deprecated."""
return x + y
ARGS = {
"alternate": "new_function"
}
- 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
|
| find_outlier_dist_guess |
Ran ran on a synthesized input |
astromedia/mcmc-analysis/utilities_mcmc_analysis.py pointer only (licence: MIT) · get_code("f81791452b1316be") How it ranThe body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, astromedia/mcmc-analysis, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| find_outlier_dist_priors |
Ran ran on a synthesized input |
astromedia/mcmc-analysis/utilities_mcmc_analysis.py pointer only (licence: MIT) · get_code("3cef807763c3b110") How it ranThe body of this sample is withheld: MIT, as GitHub detects it on this paper's repository, astromedia/mcmc-analysis, is in the permissive set, but a licence decision keeps the body a pointer: the reason for that decision is not recorded with it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| function_1d |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/autocorr.py code served (permissive licence) · get_code("96aebcf0f6d20800") How it ranRan 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 (8,) 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 simple 1-D time series
x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
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 (8,) — shape (8,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_progress_bar |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/pbar.py code served (permissive licence) · get_code("36c67203d525ecfe") How it ranRan 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 _NoOpPBar. 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 logging
# Set up logging
logging.basicConfig()
# Try to import tqdm, but set it to None to test the fallback path
try:
import tqdm
except ImportError:
tqdm = None
# Define ARGS dictionary with all parameters for get_progress_bar
ARGS = {
'display': False, # Can be bool or str; using False to test no-op case
'total': 100, # Integer representing total size of progress bar
'kwargs': {} # Optional keyword arguments dict
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type _NoOpPBar — a _NoOpPBar output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a _NoOpPBar 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
|
| initialize_random_walkers |
Ran ran on a synthesized input |
utkarshgiri/jaims/jaims/helpers.py code served (permissive licence) · get_code("9cac3d8648b0ea7a") How it ranRan 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 (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 jax
import numpy
from typing import Union, Optional
# Set seed for reproducibility
numpy.random.seed(42)
# Define dimensions for the problem
ndim = 4
nwalkers = 3
# Create initial parameter guess (loc)
loc = numpy.array([0.5, 0.5, 0.5, 0.5], dtype=numpy.float32)
# Create lower bounds
lower_bound = numpy.array([0.0, 0.0, 0.0, 0.0], dtype=numpy.float32)
# Create upper bounds
upper_bound = numpy.array([1.0, 1.0, 1.0, 1.0], dtype=numpy.float32)
# Create scale parameter - small value to keep walkers close to loc
scale = 1e-10
# Construct ARGS dictionary
ARGS = {
"nwalkers": nwalkers,
"loc": loc,
"upper_bound": upper_bound,
"lower_bound": lower_bound,
"scale": scale
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (3, 4) — shape (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
|
| is_arrval |
Ran ran on a synthesized input |
s-ilic/ECLAIR/ECLAIR_tools.py code served (permissive licence) · get_code("2a014fde8fdb2246") How it ranRan 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, 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)
ARGS = {
's': 'array(42)'
}
- 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, ndim 1, dtype family float — a list 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
|
| is_model |
Ran ran on a synthesized input |
dfm/emcee3/emcee3/model.py code served (permissive licence) · get_code("83e0386a01c5a548") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
class ModelWithComputeLogProbability(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def compute_log_probability(self, x):
return self.linear(x)
class ModelWithoutComputeLogProbability(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
# Test with a valid model
valid_model = ModelWithComputeLogProbability()
# Test with an invalid model
invalid_model = ModelWithoutComputeLogProbability()
ARGS = {
"model": valid_model
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| is_number |
Ran ran, violated the contract we drafted |
s-ilic/ECLAIR/ECLAIR_tools.py pointer only (licence: MIT); the stored copy get_code serves, from RikVN/AMR, is pointer only (licence: NONE) · get_code("e18607dae38b30e2") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from RikVN/AMR, 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. |
| krueger12_eta |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/SNPhysics/Priors.py code served (permissive licence) · get_code("6488f0ccc4df9c0a") How it ranRan 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 numpy as np
torch.manual_seed(0)
# The function krueger12_eta takes a single parameter: lpc
# lpc is described as "log10 of central density"
# The function uses it as: pc9 = 1e-09 * 10 ** lpc
# So lpc should be a numeric value (int or float)
# Looking at the function body:
# - It converts lpc to pc9 using exponential operations
# - It uses pc9 in min/max operations with arithmetic
# - It returns a tuple of two values
# lpc should be a numeric scalar value representing log10 of central density
# A reasonable test value would be around 9-10 (central densities around 1e9 g/cm^3)
ARGS = {
"lpc": 9.5
}
- 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 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
|
| lnlike |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/fitting_a_model_to_data.py code served (permissive licence) · get_code("5884b56c343520ed") How it ranRan 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 float64, ndim 0, 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
# Set random seed for reproducibility
np.random.seed(42)
# Parameters from the function signature
m_true = -0.9594
b_true = 4.294
N = 50
# Generate sample data
x = np.sort(10 * np.random.rand(N))
yerr = 0.1 + 0.5 * np.random.rand(N)
y = m_true * x + b_true
# Create theta parameter
theta = np.array([-0.95, 4.3, 0.1])
# Construct ARGS dictionary with all parameters
ARGS = {
'theta': theta,
'x': x,
'y': y,
'yerr': yerr
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| lnlike |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/basic.py code served (permissive licence) · get_code("3f80edeb0c18032f") How it ranRan 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 float64, ndim 0, 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
# Generate small synthetic data for linear regression
np.random.seed(42)
x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([2.1, 3.9, 6.2, 7.8])
# Create parameters [slope, intercept]
params = np.array([0.5, 1.0])
ARGS = {
"params": params,
"x": x,
"y": y
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| lnprior |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/fitting_a_model_to_data.py code served (permissive licence) · get_code("69d5fff3c0e4a5c2") How it ranRan 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 numpy as np
def lnprior(theta):
m, b, lnf = theta
if -5.0 < m < 0.5 and 0.0 < b < 10.0 and (-10.0 < lnf < 1.0):
return 0.0
return -np.inf
# Construct valid theta tuple with values within the prior bounds
m = -2.0 # within (-5.0, 0.5)
b = 5.0 # within (0.0, 10.0)
lnf = -5.0 # within (-10.0, 1.0)
theta = (m, b, lnf)
ARGS = {
'theta': theta
}
- 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 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
|
| lnprior |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/basic.py code served (permissive licence) · get_code("458de16e22e2fba8") How it ranRan 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 numpy as np
torch.manual_seed(0)
# The function lnprior(params) takes a single parameter 'params'
# and returns 0.0 regardless of input.
# The body doesn't actually use params, so any value works.
# We'll provide a reasonable stand-in: a dict of parameters (common in Bayesian inference)
params = {
'theta': torch.randn(2, 4),
'bias': torch.randn(3),
}
ARGS = {
'params': params,
}
- 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 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
|
| lnprob |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/fitting_a_model_to_data.py code served (permissive licence) · get_code("025078eef0025a86") How it ranRan 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 float64, ndim 0, 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
# Set random seed for reproducibility
np.random.seed(42)
# Generate data (from the function's setup)
m_true = -0.9594
b_true = 4.294
N = 50
x = np.sort(10 * np.random.rand(N))
yerr = 0.1 + 0.5 * np.random.rand(N)
y = m_true * x + b_true
# Define theta as a tuple of three parameters: (m, b, lnf)
# m: slope (should be in range -5.0 < m < 0.5)
# b: intercept (should be in range 0.0 < b < 10.0)
# lnf: log frequency factor (should be in range -10.0 < lnf < 1.0)
theta = np.array([-0.5, 2.0, -1.0])
# Construct ARGS dict with all parameters for lnprob
ARGS = {
"theta": theta,
"x": x,
"y": y,
"yerr": yerr
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| lnprob |
Ran ran on a synthesized input |
mindriot101/rust-emcee/python-tests/basic.py code served (permissive licence) · get_code("2ef998ba72abb670") How it ranRan 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 float64, ndim 0, 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
# Create simple synthetic data for linear regression
np.random.seed(0)
x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([2.1, 4.0, 5.9, 8.1])
# Create parameters (slope and intercept)
params = np.array([1.0, 0.5])
ARGS = {
"params": params,
"x": x,
"y": y
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| lnprob_gaussian |
Ran ran on a synthesized input |
mcfit/emcee/emcee/tests.py code served (permissive licence) · get_code("e5ab97b69f3ee299") How it ranRan 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 float64, ndim 0, 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
# Construct arguments for lnprob_gaussian
# The function takes:
# - x: a vector (1D array) that gets multiplied with icov
# - icov: inverse covariance matrix (2D array) that x gets multiplied with
# Create a small inverse covariance matrix (4x4)
icov = np.array([
[2.0, 0.1, 0.05, 0.02],
[0.1, 2.5, 0.08, 0.03],
[0.05, 0.08, 3.0, 0.04],
[0.02, 0.03, 0.04, 2.2]
], dtype=np.float64)
# Create a corresponding vector x (must be length 4 to match icov dimensions)
x = np.array([1.0, 0.5, -0.3, 0.8], dtype=np.float64)
ARGS = {
"x": x,
"icov": icov
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| lnprob_gaussian_nan |
Ran ran on a synthesized input |
mcfit/emcee/emcee/tests.py code served (permissive licence) · get_code("41bf464c262d6d85") How it ranRan 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 float64, ndim 0, 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
# Analyze the function:
# - x: used with np.array(x).any() and np.dot(x, np.dot(icov, x))
# So x should be array-like, 1D vector
# - icov: used with np.dot(icov, x) so it's a matrix
# Should be 2D array (inverse covariance matrix)
# Create test data
x = np.array([1.0, 2.0, 3.0, 4.0])
# Create an inverse covariance matrix (4x4 for consistency with x dimension)
icov = np.array([
[2.0, 0.1, 0.0, 0.0],
[0.1, 2.0, 0.1, 0.0],
[0.0, 0.1, 2.0, 0.1],
[0.0, 0.0, 0.1, 2.0]
])
ARGS = {
"x": x,
"icov": icov
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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_unit_sphere_volume |
Ran ran on a synthesized input |
mcfit/emcee/emcee/tests.py code served (permissive licence) · get_code("7908b07eda2604b1") How it ranRan 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 float64, ndim 0, 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
ARGS = {
"ndim": 5
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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_ladder |
Ran ran, honoured the contract we drafted |
willvousden/ptemcee/ptemcee/sampler.py code served (permissive licence) · get_code("7fbbf8658219a198") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ndarray, ndim 1, dtype family float, shape (10,) 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 make_ladder takes three parameters: ndim, ntemps, and Tmax
# Let's construct valid arguments for different scenarios
# Scenario 1: Both ntemps and Tmax specified (finite Tmax)
ARGS = {
"ndim": 5,
"ntemps": 10,
"Tmax": 100.0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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 (10,) — shape (10,) 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
|
| mi09_Enuc |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/SNPhysics/Priors.py code served (permissive licence) · get_code("0ea41cd1d9c962a6") How it ranRan 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 numpy as np
torch.manual_seed(0)
# The function takes 4 scalar parameters representing masses in solar masses
# Each parameter is used in a simple arithmetic operation
# We'll use small float values representing stellar masses
MFe = 0.5 # mass of Fe-peak elements in solar masses
MNi = 0.3 # mass of 56Ni in solar masses
MSi = 0.2 # mass of intermediate-mass elements in solar masses
MCO = 0.1 # mass of unburned C + O in solar masses
ARGS = {
"MFe": MFe,
"MNi": MNi,
"MSi": MSi,
"MCO": MCO,
}
- 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 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
|
| ndarray_to_list_of_dicts |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/ensemble.py code served (permissive licence) · get_code("f69c32b0d60425d3") How it ranRan 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, 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 numpy as np
from typing import Dict, List, Union
# Create a small parameter array of shape (N, n_dim)
# N=2 samples, n_dim=5 dimensions
x = np.array([
[1.0, 2.0, 3.0, 4.0, 5.0],
[6.0, 7.0, 8.0, 9.0, 10.0]
], dtype=np.float32)
# Create a key_map that maps parameter names to indices or lists of indices
key_map = {
'param_a': 0,
'param_b': 1,
'param_c': [2, 3],
'param_d': 4
}
ARGS = {
'x': x,
'key_map': key_map
}
- 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 list, ndim 1, dtype family float — a list 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
|
| next_pow_two |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/autocorr.py code served (permissive licence) · get_code("3f0eeafa1475e678") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
def next_pow_two(n):
"""Returns the next power of two greater than or equal to `n`"""
i = 1
while i < n:
i = i << 1
return i
# Test with various integer values
ARGS = {
'n': 7
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| rho_exp |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/run_J99_qint.py code served (permissive licence) · get_code("a3a6c2d96465ec4c") How it ranRan 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
def rho_exp(v):
"""Baseline exponential density profile"""
return np.exp(-v)
# Create a small numpy array as input
v = np.array([0.0, 0.5, 1.0, 1.5])
ARGS = {
"v": v
}
- 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
|
| rho_pow3x3 |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/run_J99_qint.py code served (permissive licence) · get_code("54cbebc123331570") How it ranRan 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 (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
torch.manual_seed(0)
# The function rho_pow3x3 takes a single parameter v and applies mathematical operations to it
# v should be a numeric value or array-like object that supports ** (power) operations
# The function computes (1 + v ** 3) ** (-3)
# Create a small test value - can be a scalar, numpy array, or torch tensor
v = torch.tensor([0.5, 1.0, 1.5, 2.0], dtype=torch.float32)
ARGS = {
"v": v
}
- 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 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
|
| rho_pow7 |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/run_J99_qint.py code served (permissive licence) · get_code("e9d5fe648035b99e") How it ranRan 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 (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
torch.manual_seed(0)
# The function rho_pow7 takes a single parameter v
# It performs: 1.0 / (1 + v ** 7)
# v should be a numeric value or array-like that supports exponentiation
# Create a small tensor to serve as the input
v = torch.tensor([0.5, 1.5, 2.0, 0.1], dtype=torch.float32)
ARGS = {
"v": v
}
- 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 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
|
| sample_ball |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/utils.py code served (permissive licence) · get_code("4d5bb6b1f4a2b6ec") How it ranRan 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 (5, 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
import warnings
# Set seed for reproducibility
np.random.seed(42)
# Create arguments for sample_ball function
p0 = np.array([1.0, 2.0, 3.0, 4.0]) # Initial parameter value
std = np.array([0.1, 0.2, 0.15, 0.25]) # Axis-aligned standard deviation
size = 5 # Number of samples to produce
ARGS = {
'p0': p0,
'std': std,
'size': size
}
- 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 (5, 4) — shape (5, 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
|
| sample_ball |
Ran ran on a synthesized input |
mcfit/emcee/emcee/utils.py code served (permissive licence) · get_code("b5e99a69e04794a1") How it ranRan 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 (5, 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 initial parameter value as a 1D numpy array
p0 = np.array([1.0, 2.0, 3.0, 4.0])
# Create standard deviation array with same length as p0
std = np.array([0.1, 0.2, 0.15, 0.25])
# Number of samples to produce
size = 5
ARGS = {
"p0": p0,
"std": std,
"size": size
}
- 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 (5, 4) — shape (5, 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
|
| sample_ellipsoid |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/utils.py code served (permissive licence) · get_code("6b0c6f7916ecccfe") How it ranRan 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 (5, 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
import warnings
# Set random seed for reproducibility
np.random.seed(42)
# Define arguments for sample_ellipsoid
# p0: initial parameter value - a 1D array
p0 = np.array([1.0, 2.0, 3.0])
# covmat: covariance matrix - must be symmetric positive definite
# Creating a simple 3x3 symmetric positive definite matrix
covmat = np.array([
[2.0, 0.5, 0.1],
[0.5, 1.5, 0.2],
[0.1, 0.2, 1.0]
])
# size: number of samples to produce
size = 5
ARGS = {
'p0': p0,
'covmat': covmat,
'size': size
}
- 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 (5, 3) — shape (5, 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
|
| sample_ellipsoid |
Ran ran on a synthesized input |
mcfit/emcee/emcee/utils.py code served (permissive licence) · get_code("9144989af6b02a26") How it ranRan 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 (5, 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)
# p0: initial parameter value - a 1D array
p0 = np.array([1.0, 2.0, 3.0])
# covmat: covariance matrix - must be symmetric positive definite
# Create a simple symmetric positive definite matrix
covmat = np.array([
[2.0, 0.5, 0.1],
[0.5, 1.5, 0.2],
[0.1, 0.2, 1.0]
])
# size: number of samples to produce
size = 5
ARGS = {
'p0': p0,
'covmat': covmat,
'size': size
}
- 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 (5, 3) — shape (5, 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
|
| splt |
Ran ran on a synthesized input |
s-ilic/ECLAIR/ECLAIR_tools.py code served (permissive licence) · get_code("edd64bf4e6addaa8") How it ranRan 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, 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.
ARGS = {
's': 'hello world "foo bar" baz',
'sep': None,
'maxsplit': -1
}
- 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 list, ndim 1, dtype family float — a list 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
|
| walkers_independent |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/ensemble.py code served (permissive licence) · get_code("19462bd6634e1504") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a valid coords array
# The function expects:
# - A 2D array of coordinates
# - Finite values (no NaN or inf)
# - Multiple points (rows) with multiple dimensions (columns)
# - Points should not all be identical
# - Points should have variation across dimensions
np.random.seed(0)
# Create a small set of walker coordinates
# Shape: (num_walkers, num_dimensions)
# Using distinct sizes: 5 walkers, 3 dimensions
coords = np.random.randn(5, 3).astype(np.float64)
# Ensure the coordinates are finite and have variation
# by scaling appropriately to avoid numerical issues
coords = coords * 10.0
ARGS = {
"coords": coords
}
- 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 bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| walkers_independent_cov |
Ran ran on a synthesized input |
dfm/emcee/src/emcee/ensemble.py code served (permissive licence) · get_code("f53cf8bd70e2f5a2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create valid input for walkers_independent_cov
# The function expects 'coords' which should be a 2D array of shape (n_samples, n_features)
# Create a small coordinate array with shape (5, 3) - 5 samples, 3 features
coords = np.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[2.5, 3.5, 4.5],
[5.5, 6.5, 7.5]
], dtype=float)
ARGS = {
"coords": coords
}
- 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 bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| yl05_bind |
Ran ran on a synthesized input |
rscalzo/pyBoloSN/SNPhysics/Priors.py code served (permissive licence) · get_code("d23887d53edd1531") How it ranRan 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 float64, ndim 0, 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
class BadInputError(Exception):
pass
# Valid test case: MWD slightly larger than MNR, lpc > 0
lpc_value = 8.5 # log10 central density
MWD_value = 1.44 # mass of white dwarf in solar masses
ARGS = {
'MWD': MWD_value,
'lpc': lpc_value
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| SNMCMC_EBMV |
Not yet run unverified (harvested, no recorded run) |
rscalzo/pyBoloSN/SNMCMC/SNMCMC_EBMV.py code served (permissive licence) · get_code("b1a6537510358554") How it ran |
| default_grad_log_prior_function |
Not yet run unverified (harvested, no recorded run) |
dfm/emcee3/emcee3/model.py code served (permissive licence) · get_code("e76836fad9dcb79e") How it ran |
| default_log_prior_function |
Not yet run unverified (harvested, no recorded run) |
dfm/emcee3/emcee3/model.py code served (permissive licence) · get_code("f68e52fd7f0ce48a") How it ran |
| function |
Not yet run unverified (harvested, no recorded run) |
dfm/emcee3/emcee3/autocorr.py code served (permissive licence) · get_code("4cd7e818c2722e55") How it ran |
| integrated_time |
Not yet run unverified (harvested, no recorded run) |
dfm/emcee3/emcee3/autocorr.py code served (permissive licence) · get_code("cd91b69a4f3e3775") How it ran |
| integrated_time |
Not yet run unverified (harvested, no recorded run) |
mcfit/emcee/emcee/autocorr.py code served (permissive licence) · get_code("6449332d84bd4e37") How it ran |