| PartitionsAsBlocklabels |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/combin/partitions.py code served (permissive licence) · get_code("84e5da8d52aeb6f6") 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 map. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
ARGS = {
'n': 4
}
- 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 map — a map output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a map 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
|
| blocklabels_to_flagvector |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/combin/partitions.py code served (permissive licence) · get_code("ff70ee27c442a857") 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 int, 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
# Understand the function:
# - labels: m-vector with entries in {0,...,2**n-1}
# These are indices into the output array
# - sz: must be 2**n, the size of the output array
# - dtype: data type for the output
#
# The function creates a zero array of size sz with given dtype,
# then sets r[labels] = 1, so labels must be valid indices into an array of size sz.
#
# Example: if sz=8 (so n=3), labels could be [0, 2, 5] (3 blocks)
# Result would be a vector of length 8 with 1s at positions 0, 2, 5
# Create valid arguments
labels = np.array([0, 2, 5], dtype=np.int64) # 3 blocks
sz = 8 # 2**3 = 8 elements in the partitioned set
dtype = int
ARGS = {
"labels": labels,
"sz": sz,
"dtype": dtype
}
- 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 int, 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
|
| cs |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/adtools.py code served (permissive licence) · get_code("2f2a728ee2342d83") 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 numpy as np
def simple_func(x):
"""A simple function that works with complex step derivative."""
return np.sin(x) + 2 * x**2
def array_func(x):
"""A function that works elementwise on arrays."""
return np.exp(x) - np.cos(x)
# Test with scalar
scalar_x = 1.5
# Test with array
array_x = np.array([0.1, 0.2, 0.3, 0.5])
ARGS = {
"f": simple_func,
"x": scalar_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 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
|
| cs_erfinv |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/erf_tools.py code served (permissive licence) · get_code("1968757262788202") 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 import special
# Test with both real and complex inputs
# The function accepts a single parameter p which can be real or complex
# Real scalar
real_scalar = 0.5
# Complex scalar
complex_scalar = 0.3 + 0.1j
# Real array
real_array = np.array([0.1, 0.5, 0.9])
# Complex array
complex_array = np.array([0.2 + 0.05j, 0.5 + 0.1j, 0.8 + 0.02j])
# Using a real scalar as the main test case
ARGS = {
"p": real_scalar
}
- 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
|
| erf |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/erf_tools.py code served (permissive licence) · get_code("d504382c533f0747") 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
from scipy import special
sqrtpi = np.sqrt(np.pi)
def erf(x, deriv=False):
y = special.erf(x)
if not deriv:
return y
return (y, lambda dy: 2.0 / sqrtpi * dy * np.exp(-x ** 2))
# Setup: construct valid arguments
x = np.array([0.5, 1.0, -0.3, 0.0])
deriv = False
ARGS = {
"x": x,
"deriv": deriv
}
- 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 (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
|
| erf_and_logderiv |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/erf_tools.py code served (permissive licence) · get_code("3305ad9c04c0c4ba") 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 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy import special
# Set random seed for reproducibility
np.random.seed(0)
# Create test inputs
x = np.array([0.5, 1.2, -0.3, 2.1], dtype=np.float64)
# Define ARGS dictionary with all parameters
ARGS = {
'x': x,
'deriv': False,
}
- 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 tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| k012e |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/besselk.py code served (permissive licence) · get_code("43809375625a7a32") 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 scipy.special as special
import numpy as np
# Test with a real scalar value
real_x = 2.5
# Test with a complex scalar value
complex_x = 2.5 + 1.0j
# Test with a real array
real_array = np.array([1.0, 2.0, 3.0, 4.0])
# Test with a complex array
complex_array = np.array([1.0 + 0.5j, 2.0 + 1.0j, 3.0 + 1.5j, 4.0 + 2.0j])
# Create ARGS dict with different test cases
ARGS = {
"x": real_x
}
- 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 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
|
| k0e |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/besselk.py code served (permissive licence) · get_code("df374dee154cb865") 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 scipy.special as special
import numpy as np
# The function k0e(x) takes a single parameter x
# It checks if x is complex using np.iscomplexobj(x)
# If complex, it calls special.kve(0, x)
# If not complex, it calls special.k0e(x)
# Both scipy functions accept array-like inputs
# Test with a real-valued numpy array
x_real = np.array([0.5, 1.0, 1.5, 2.0])
ARGS = {
"x": x_real
}
- 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 (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
|
| k1e |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/besselk.py code served (permissive licence) · get_code("9ef74bb813161dd7") 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 scipy.special as special
import numpy as np
import torch
torch.manual_seed(0)
# The function k1e takes a single parameter x
# It checks if x is a complex object, then calls either special.kve(1, x) or special.k1e(x)
# Both scipy special functions accept array-like inputs
# Test with real numpy array
x_real = np.array([0.5, 1.0, 2.0, 3.0])
ARGS = {
"x": x_real
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, torch — 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
|
| labels_to_1hotmatrix |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/combin/partitions.py code served (permissive licence) · get_code("5d6e193b04f14b0a") 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 int, shape (3, 6) 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 restricted growth string
# A restricted growth string has:
# - first entry is 0
# - each subsequent entry cannot exceed the max of previous entries by more than 1
labels = np.array([0, 1, 1, 2, 2, 1], dtype=int)
ARGS = {
"labels": labels,
"dtype": int
}
- 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 int, shape (3, 6) — shape (3, 6) 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
|
| logprob_alpha |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/prob/crp.py code served (permissive licence) · get_code("b89ae8ae46f97e4e") 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.special import gammaln, psi
np.random.seed(0)
# Analyze the function:
# - alpha: a positive scalar (float)
# - counts: a sequence/array where len(counts) gives K (number of categories)
# and sum(counts) gives T (total count)
# Individual elements are used with gammaln(counts) - needs to be numeric
# Create small valid arguments
alpha = 2.5 # positive scalar
# counts should be a sequence of counts
# Let's make K=4 distinct categories with small counts
counts = [1, 2, 3, 2] # K=4, T=8
ARGS = {
"alpha": alpha,
"counts": counts,
}
- 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
|
| logprob_alpha_beta |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/prob/crp.py code served (permissive licence) · get_code("1d37d674cf3f39f3") 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 valid arguments for logprob_alpha_beta
# The function expects:
# - alpha: float > 0
# - beta: float where 0 < beta < 1
# - counts: list/array of counts (non-negative integers)
# Create valid parameters
alpha = 2.5 # Must be > 0
beta = 0.3 # Must be 0 < beta < 1
counts = np.array([2, 3, 1, 4]) # Array of counts, all positive integers
# Verify constraints before building ARGS
assert alpha > 0, "alpha must be > 0"
assert 0 < beta < 1, "beta must be between 0 and 1 (exclusive)"
assert all(c > beta for c in counts), "all counts must be > beta for gammaln(counts - beta) to be valid"
ARGS = {
"alpha": alpha,
"beta": beta,
"counts": counts
}
- 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
|
| logsumexp |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/adfunctions.py code served (permissive licence) · get_code("f64ca25c9836a19a") 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 (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
# Set random seed for reproducibility
np.random.seed(0)
# Create a small input array for logsumexp
# Shape: (2, 3) - 2 samples, 3 dimensions
X = np.random.randn(2, 3).astype(np.float64)
# Define ARGS with all parameters
ARGS = {
"X": X,
"axis": 0,
"keepdims": False,
"deriv": False,
}
- 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
|
| raug |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/adtools.py code served (permissive licence) · get_code("8f2cd7ed3c038987") 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 complex, 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
# Test case 1: scalar inputs
x_scalar = 5.0
r_scalar = 2.0
# Test case 2: numpy array inputs
x_array = np.array([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]])
r_array = np.array([[0.1, 0.2, 0.3, 0.4],
[0.5, 0.6, 0.7, 0.8]])
# Test case 3: tuple of scalars
x_tuple_scalar = (1.0, 2.0, 3.0)
r_tuple_scalar = (0.1, 0.2, 0.3)
# Test case 4: tuple of arrays
x_array1 = np.array([1.0, 2.0, 3.0, 4.0])
r_array1 = np.array([0.1, 0.2, 0.3, 0.4])
x_array2 = np.array([5.0, 6.0, 7.0, 8.0])
r_array2 = np.array([0.5, 0.6, 0.7, 0.8])
x_tuple_array = (x_array1, x_array2)
r_tuple_array = (r_array1, r_array2)
# Test case 5: nested tuple structure
x_nested = (1.0, (2.0, 3.0))
r_nested = (0.1, (0.2, 0.3))
# Using scalar case as primary test
ARGS = {
'x': x_scalar,
'r': r_scalar,
'eps': 1e-20j
}
- 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 complex, 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
|
| rdot |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/adtools.py code served (permissive licence) · get_code("4d6df300e2ac88a3") 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
# Test case 1: two scalars
x_scalar = 3.5
y_scalar = 2.0
# Test case 2: two ndarrays with same shape
x_array = np.array([1.0, 2.0, 3.0, 4.0])
y_array = np.array([5.0, 6.0, 7.0, 8.0])
# Test case 3: nested tuple structure with scalars and arrays
x_nested = (
1.5,
np.array([1.0, 2.0]),
(
2.5,
np.array([[1.0, 2.0], [3.0, 4.0]])
)
)
y_nested = (
2.5,
np.array([3.0, 4.0]),
(
3.5,
np.array([[5.0, 6.0], [7.0, 8.0]])
)
)
# Use the scalar case as the main test case
ARGS = {
'x': x_scalar,
'y': y_scalar
}
- 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
|
| softplus |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/softplus.py code served (permissive licence) · get_code("d82cc22f6cca675b") 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 (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 numpy as np
def softplus(x):
"""log( 1 + exp(x) )"""
return np.log1p(np.exp(-np.abs(x))) + np.maximum(x, 0)
# Create test input - a small numpy array
x = np.array([[-2.5, -1.0, 0.0, 1.5],
[2.0, -0.5, 0.5, 3.0]], dtype=np.float32)
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 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
|
| softplusinv |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/special/softplus.py code served (permissive licence) · get_code("e4239541a6ea39c3") 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
# Construct a small numpy array to pass as y
# The function expects a numpy array (or array-like) and performs mathematical operations
y = np.array([0.5, 1.0, 2.0, -0.5])
ARGS = {
"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 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
|
| squeeze |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/adfunctions.py code served (permissive licence) · get_code("e56c64810abf04fe") 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 int, shape (2, 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
# Test case 1: 2D array with axis=0
A1 = np.array([[1, 2, 3], [4, 5, 6]])
# Test case 2: 3D array with axis=1
A2 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
# Test case 3: array with singleton dimension to squeeze to scalar
A3 = np.array([[[42]]])
# Use the first test case for the main ARGS
ARGS = {
"A": A1,
"axis": 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 2, dtype family int, shape (2, 3) — shape (2, 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
|
| sum2shape |
Ran ran on a synthesized input |
bsxfan/probabilistic_embeddings/lib/deriv/broadcast_adtools.py code served (permissive licence) · get_code("f606a62d87466fd7") 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 (2, 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
# Test case 1: x already matches to_shape
x1 = np.array([[1, 2], [3, 4]])
to_shape1 = (2, 2)
# Test case 2: x needs to be summed to match to_shape (scalar output)
x2 = np.array([[1, 2, 3], [4, 5, 6]])
to_shape2 = ()
# Test case 3: x needs to be summed along one axis to match to_shape
x3 = np.random.randn(4, 1, 3)
to_shape3 = (4, 1, 3)
# Test case 4: x needs broadcasting-like summing
x4 = np.random.randn(2, 3, 4)
to_shape4 = (2, 1, 4)
# Use test case 1 as the primary example
ARGS = {
"x": np.array([[1.0, 2.0], [3.0, 4.0]]),
"to_shape": (2, 2)
}
- 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 (2, 2) — shape (2, 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
|
| logprob_beta |
Not yet run unverified (harvested, no recorded run) |
bsxfan/probabilistic_embeddings/lib/prob/crp.py code served (permissive licence) · get_code("a6571a54ed4fb4d9") How it ran |
| sum2sh |
Not yet run unverified (harvested, no recorded run) |
bsxfan/probabilistic_embeddings/lib/deriv/broadcast_adtools.py code served (permissive licence) · get_code("3bcb697e90534a24") How it ran |