| decoder_mlp |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("cff28b13a507c1e4") 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 ArrayImpl, 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 jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small parameter matrices for the MLP
# params is a list of [W, b] pairs for each layer
# We'll create a 2-layer network: input(4) -> hidden(3) -> output(2)
W_hidden = jnp.array(np.random.randn(4, 3), dtype=jnp.float32)
b_hidden = jnp.array(np.random.randn(3), dtype=jnp.float32)
W_output = jnp.array(np.random.randn(3, 2), dtype=jnp.float32)
b_output = jnp.array(np.random.randn(2), dtype=jnp.float32)
params = [
[W_hidden, b_hidden],
[W_output, b_output]
]
# Create input data: batch_size=2, input_dim=4
x = jnp.array(np.random.randn(2, 4), dtype=jnp.float32)
# Define ARGS dictionary with all parameters
ARGS = {
'params': params,
'x': x,
'activation': 'xtanh',
'slope': 0.1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, 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
|
| encoder_mlp |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("9cbf0cb80a2d5aa6") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import jax.nn as nn
# Set seed for reproducibility
jax.config.update('jax_platform_name', 'cpu')
# Define a small stand-in class for SmoothLeakyRelu activation
class SmoothLeakyRelu:
def __init__(self, slope):
self.slope = slope
def __call__(self, x):
return jnp.where(x > 0, x, self.slope * x)
# Create small parameter matrices for the MLP
# Input dimension: 4, hidden dimension: 3, output dimension: 8 (split into v and W_diag)
batch_size = 2
input_dim = 4
hidden_dim = 3
output_dim = 8 # Will be split into v (4) and W_diag (4)
# Initialize random key for JAX
key = jax.random.PRNGKey(0)
# Create params: list of [W, b] pairs for each layer
# Layer 1: input_dim -> hidden_dim
key, subkey = jax.random.split(key)
W1 = jax.random.normal(subkey, (input_dim, hidden_dim)) * 0.1
b1 = jnp.zeros(hidden_dim)
# Layer 2 (output): hidden_dim -> output_dim
key, subkey = jax.random.split(key)
W2 = jax.random.normal(subkey, (hidden_dim, output_dim)) * 0.1
b2 = jnp.zeros(output_dim)
params = [[W1, b1], [W2, b2]]
# Create input data
key, subkey = jax.random.split(key)
x = jax.random.normal(subkey, (batch_size, input_dim))
ARGS = {
'params': params,
'x': x,
'activation': 'xtanh',
'slope': 0.1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| gaussian_entropy |
Ran ran, honoured the contract we drafted |
HHalva/snica/elbo.py code served (permissive licence) · get_code("38c1891fa5bd8cbf") 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 ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Create a small positive definite matrix to use as precision matrix
# A precision matrix must be symmetric positive definite
np.random.seed(0)
A = np.random.randn(4, 4)
prec_np = A @ A.T # Ensure positive definiteness
prec = jnp.array(prec_np, dtype=jnp.float32)
ARGS = {
"prec": prec
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_E_prior_natparams |
Ran ran, honoured the contract we drafted |
HHalva/snica/elbo.py code served (permissive licence) · get_code("03e0c98299716c51") 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 ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create a small positive definite matrix for J_prior (4x4)
# J_prior should be negative definite for the function to work properly
# We'll create a symmetric negative definite matrix
dim = 4
A = np.random.randn(dim, dim)
J_prior_pos = A @ A.T # Positive definite
J_prior = -J_prior_pos # Make it negative definite
# Create h_prior vector (4,)
h_prior = np.random.randn(dim)
# eta_prior is a tuple of (h_prior, J_prior)
eta_prior = (jnp.array(h_prior, dtype=jnp.float32),
jnp.array(J_prior, dtype=jnp.float32))
# Create qz_prior as a tuple (Ez, cov_chol)
# Ez is the mean (4,)
Ez = np.random.randn(dim)
# cov_chol should be a Cholesky factor of a covariance matrix
# Create a small positive definite covariance matrix and get its Cholesky
cov = np.random.randn(dim, dim)
cov = cov @ cov.T + np.eye(dim) # Ensure positive definite
cov_chol = np.linalg.cholesky(cov)
qz_prior = (jnp.array(Ez, dtype=jnp.float32),
jnp.array(cov_chol, dtype=jnp.float32))
ARGS = {
"qz_prior": qz_prior,
"eta_prior": eta_prior
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_expected_suffstats |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("153e0c15ecc40d16") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Construct qz as a tuple of (Ez, Sigma)
# where Ez is a mean vector and Sigma is a covariance matrix
# Create a small positive definite matrix for the covariance
dim = 4
np.random.seed(0)
A = np.random.randn(dim, dim)
Sigma = A @ A.T + np.eye(dim) # Ensure positive definiteness
# Convert to JAX arrays
Ez = jnp.array(np.random.randn(dim), dtype=jnp.float32)
Sigma_jax = jnp.array(Sigma, dtype=jnp.float32)
# qz is a tuple containing (Ez, Sigma)
qz = (Ez, Sigma_jax)
ARGS = {
"qz": qz
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_gauss_params |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("648b15b09780817d") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small positive definite matrices for testing
# P should be negative definite (as used in the function: -P becomes positive definite)
dim = 4
# Create a random matrix and make it negative definite
A = np.random.randn(dim, dim)
P_base = A @ A.T # This is positive definite
P = -P_base # Make it negative definite as expected by the function
# Convert to JAX arrays
P_jax = jnp.array(P, dtype=jnp.float32)
# Create eta vector
eta = jnp.array(np.random.randn(dim), dtype=jnp.float32)
# natparams is a tuple of (eta, P)
natparams = (eta, P_jax)
ARGS = {
"natparams": natparams
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_hmm_natparams |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("a72598d6c478c2b3") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax.numpy as jnp
import numpy as np
# Create small HMM parameters
# pi: initial state distribution (probability vector)
# A: transition matrix (stochastic matrix)
num_states = 3
# Create a valid probability vector for pi
pi = jnp.array([0.5, 0.3, 0.2])
# Create a valid stochastic transition matrix A
# Each row should sum to 1
A = jnp.array([
[0.7, 0.2, 0.1],
[0.1, 0.8, 0.1],
[0.2, 0.2, 0.6]
])
hmm_params = (pi, A)
ARGS = {
"hmm_params": hmm_params
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_prec_mat |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("68aad677664d6b6a") 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 ArrayImpl, ndim 2, dtype family float, shape (4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import jax.random as jrandom
# Set up a JAX PRNG key
key = jrandom.PRNGKey(0)
# Define arguments for get_prec_mat
ARGS = {
"n": 4,
"prec_scale": 2.0,
"key": key
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 2, dtype family float, shape (4, 4) — shape (4, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_prior_natparams |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("2ca8127a658964aa") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Analyze the function:
# - Takes params which is unpacked as (b_init_k, Q_init_k)
# - b_init_k is used in matrix multiplication: Q_init_k @ b_init_k
# - Q_init_k is used in matrix multiplication and scalar multiplication
# - Both appear to be matrices/tensors
# Create small tensors with distinct dimensions
# Q_init_k should be square (for @ operation and -0.5 * Q_init_k to make sense)
# b_init_k should be a vector that Q_init_k can multiply with
b_init_k = torch.randn(4, 1) # Column vector: 4x1
Q_init_k = torch.randn(4, 4) # Square matrix: 4x4
params = (b_init_k, Q_init_k)
ARGS = {
"params": params
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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 — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_resp_wgt_natparams |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("65e9fd940b57f3cd") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax.numpy as jnp
import numpy as np
# Construct arguments for get_resp_wgt_natparams
# The function expects:
# - natparams: a tuple of (h, J) where h and J are arrays
# - qu: an array of weights/responsibilities
# h: shape (batch_size, feature_dim) - natural parameter for linear term
h = jnp.array([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]]) # shape (2, 4)
# J: shape (batch_size, feature_dim, feature_dim) - natural parameter for quadratic term
J = jnp.array([[[1.0, 0.1, 0.2, 0.3],
[0.1, 2.0, 0.4, 0.5],
[0.2, 0.4, 3.0, 0.6],
[0.3, 0.5, 0.6, 4.0]],
[[5.0, 0.2, 0.3, 0.4],
[0.2, 6.0, 0.5, 0.6],
[0.3, 0.5, 7.0, 0.7],
[0.4, 0.6, 0.7, 8.0]]]) # shape (2, 4, 4)
natparams = (h, J)
# qu: shape (batch_size,) - responsibility weights
qu = jnp.array([0.3, 0.7]) # shape (2,)
ARGS = {
"natparams": natparams,
"qu": qu
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_transition_natparams |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("94d921c73051af5a") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax.numpy as jnp
import numpy as np
# Construct small valid arguments for get_transition_natparams
# The function expects params = (B_k, b_k, Q_k)
# where:
# - B_k is a matrix of shape (d, d) used in matrix multiplications
# - b_k is a vector of shape (d,)
# - Q_k is a matrix of shape (d, d) used in matrix multiplications
d = 4 # dimension
# Create B_k as a (d, d) matrix
B_k = jnp.array(np.random.randn(d, d), dtype=jnp.float32)
# Create b_k as a (d,) vector
b_k = jnp.array(np.random.randn(d), dtype=jnp.float32)
# Create Q_k as a (d, d) matrix (should be positive definite for physical meaning)
Q_k = jnp.array(np.eye(d) + 0.1 * np.random.randn(d, d), dtype=jnp.float32)
# Construct params tuple
params = (B_k, b_k, Q_k)
ARGS = {
"params": params
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| hmm_bwd_pass |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
hhalva/snica/inference.py code served (permissive licence) · get_code("4b78ecd3b19a07fb") 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 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 jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small test arrays for HMM backward pass
# eta_in: backward message from next timestep, shape (num_states,)
num_states = 4
eta_in = jnp.array([-1.2, -0.5, -2.1, -0.8])
# eta_current is a tuple of (eta_A, eta_likelihood)
# eta_A: transition matrix log-probabilities, shape (num_states, num_states)
eta_A = jnp.array([
[-0.5, -1.0, -2.0, -3.0],
[-1.5, -0.3, -1.2, -2.5],
[-2.0, -1.8, -0.4, -1.0],
[-1.0, -2.0, -1.5, -0.6]
])
# eta_likelihood: emission log-probabilities for current timestep, shape (num_states,)
eta_likelihood = jnp.array([-0.3, -1.5, -0.8, -2.0])
eta_current = (eta_A, eta_likelihood)
ARGS = {
"eta_in": eta_in,
"eta_current": eta_current
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — 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
|
| hmm_pw_post |
Ran ran, violated the contract we drafted |
hhalva/snica/inference.py code served (permissive licence) · get_code("b8174628a0f6976c") 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 ArrayImpl, 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 jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small test arrays for HMM forward-backward algorithm
# eta_fwd: shape (batch_size,) - log probabilities from forward pass
eta_fwd = jnp.array([0.1, -0.5])
# eta_transition: shape (batch_size, num_states) - log transition probabilities
eta_transition = jnp.array([
[0.2, -0.3, 0.1, -0.2],
[-0.1, 0.4, -0.2, 0.3]
])
# rho: shape (num_states,) - log observation probabilities
rho = jnp.array([0.05, -0.15, 0.25, -0.35])
# eta_bwd: shape (num_states,) - log probabilities from backward pass
eta_bwd = jnp.array([0.1, -0.2, 0.3, -0.1])
ARGS = {
"eta_fwd": eta_fwd,
"eta_transition": eta_transition,
"rho": rho,
"eta_bwd": eta_bwd,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, 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
|
| invcholp |
Ran ran, honoured the contract we drafted |
HHalva/snica/elbo.py code served (permissive licence) · get_code("69720ea7afdb3d5c") 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 ArrayImpl, ndim 2, dtype family float, shape (4, 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 jax
import jax.numpy as jnp
import numpy as np
# Create small test matrices for the invcholp function
# L should be a lower triangular matrix (from Cholesky decomposition)
# Y should be a matrix to solve for
np.random.seed(0)
# Create a small positive definite matrix and compute its Cholesky decomposition
A = np.array([[4.0, 1.0, 0.5, 0.2],
[1.0, 3.0, 0.3, 0.1],
[0.5, 0.3, 2.0, 0.4],
[0.2, 0.1, 0.4, 1.5]], dtype=np.float32)
# Compute Cholesky decomposition to get L
L_np = np.linalg.cholesky(A)
L = jnp.array(L_np, dtype=jnp.float32)
# Create Y as a random matrix with compatible dimensions
Y_np = np.random.randn(4, 2).astype(np.float32)
Y = jnp.array(Y_np, dtype=jnp.float32)
ARGS = {
"L": L,
"Y": Y
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 2, dtype family float, shape (4, 2) — shape (4, 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
|
| invmp |
Ran ran, honoured the contract we drafted |
HHalva/snica/elbo.py code served (permissive licence) · get_code("4a16dfb0110cd963") 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 ArrayImpl, 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 jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create a small positive definite matrix for X
# We need X to be square and positive definite so that cholesky works
X = jnp.array([
[4.0, 1.0, 0.5, 0.2],
[1.0, 3.0, 0.3, 0.1],
[0.5, 0.3, 2.0, 0.4],
[0.2, 0.1, 0.4, 1.5]
], dtype=jnp.float32)
# Create Y as a matrix with different dimensions than X
# Y should have the same number of rows as X (4) but different columns (3)
Y = jnp.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[10.0, 11.0, 12.0]
], dtype=jnp.float32)
ARGS = {
"X": X,
"Y": Y
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, 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
|
| lds_bwd_pass |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("bf63979b0a0ee025") 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. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Construct arguments for lds_bwd_pass function
# in_natparams and current_natparams are both tuples containing natural parameters
# Dimension of the state
d = 4
# Create in_natparams: a tuple of (eta_in, P_in)
# eta_in is a vector of shape (d,)
# P_in is a matrix of shape (d, d)
eta_in = jnp.array(np.random.randn(d), dtype=jnp.float32)
P_in = jnp.array(np.random.randn(d, d), dtype=jnp.float32)
in_natparams = (eta_in, P_in)
# Create current_natparams: a tuple of (trans_natparams, likelih_natparams)
# trans_natparams is (h, J) where:
# h has shape (2*d,) - concatenation of h_a and h_b
# J has shape (2*d, 2*d) - block matrix with J_aa, J_ab, J_ba, J_bb
h = jnp.array(np.random.randn(2*d), dtype=jnp.float32)
J = jnp.array(np.random.randn(2*d, 2*d), dtype=jnp.float32)
trans_natparams = (h, J)
# likelih_natparams should be compatible with tree_sum operation
# It should have the same structure as in_natparams for tree_sum to work
# likelih_natparams is (eta_l, P_l) with same shapes
eta_l = jnp.array(np.random.randn(d), dtype=jnp.float32)
P_l = jnp.array(np.random.randn(d, d), dtype=jnp.float32)
likelih_natparams = (eta_l, P_l)
current_natparams = (trans_natparams, likelih_natparams)
ARGS = {
"in_natparams": in_natparams,
"current_natparams": current_natparams,
}
- 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 tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lds_entropy |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("2a043e11c7f38e65") 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 ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create small positive definite matrices for precision matrices
# qz_prec: shape (batch, time, dim, dim)
# Each precision matrix must be positive definite (symmetric and positive definite)
def create_positive_definite(dim):
"""Create a small positive definite matrix"""
A = np.random.randn(dim, dim)
return A @ A.T + np.eye(dim)
batch_size = 2
time_steps = 5
dim = 4
# qz_prec: (batch, time, dim, dim) - precision matrices for each timestep
# The function vmaps over the first dimension (batch) and then over [1:-1] slice of time
qz_prec = jnp.array([
[create_positive_definite(dim) for _ in range(time_steps)]
for _ in range(batch_size)
])
# qzlag_z_prec: (batch, time-1, dim, dim) - pairwise precision matrices
# The function vmaps vmap over this twice
qzlag_z_prec = jnp.array([
[create_positive_definite(dim) for _ in range(time_steps - 1)]
for _ in range(batch_size)
])
ARGS = {
"qz_prec": qz_prec,
"qzlag_z_prec": qzlag_z_prec
}
- 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 ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lds_fwd_pass |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("77c8fb11db6615a7") 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. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax
import jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Analyze the function requirements:
# - in_natparams: tuple of (eta_in, P_in)
# - eta_in: shape (d,) vector
# - P_in: shape (d, d) matrix (used in -J_aa - P_in which is fed to invmp)
# - current_natparams: tuple of (trans_natparams, likelih_natparams)
# - trans_natparams: tuple of (h, J)
# - h: shape (2*d,) vector (split into h_a and h_b of size d each)
# - J: shape (2*d, 2*d) matrix (split into J_aa, J_ab, J_ba, J_bb)
# - likelih_natparams: tuple of (natparam_vec, natparam_matrix)
# Use d=4 as the state dimension
d = 4
# Build eta_in: shape (d,)
eta_in = jnp.array(np.random.randn(d), dtype=jnp.float32)
# Build P_in: shape (d, d), must be positive definite for the cholesky decomposition
# Create a symmetric positive definite matrix
P_in_temp = np.random.randn(d, d)
P_in = jnp.array(P_in_temp @ P_in_temp.T + np.eye(d), dtype=jnp.float32)
# Build h: shape (2*d,)
h = jnp.array(np.random.randn(2*d), dtype=jnp.float32)
# Build J: shape (2*d, 2*d), must be negative definite for -J_aa - P_in to be positive definite
# Create a symmetric negative definite matrix
J_temp = np.random.randn(2*d, 2*d)
J = jnp.array(-(J_temp @ J_temp.T + np.eye(2*d)), dtype=jnp.float32)
# Build likelih_natparams: tuple of (vec, matrix)
likelih_vec = jnp.array(np.random.randn(d), dtype=jnp.float32)
likelih_mat_temp = np.random.randn(d, d)
likelih_mat = jnp.array(likelih_mat_temp @ likelih_mat_temp.T + np.eye(d), dtype=jnp.float32)
likelih_natparams = (likelih_vec, likelih_mat)
# Construct the arguments
in_natparams = (eta_in, P_in)
trans_natparams = (h, J)
current_natparams = (trans_natparams, likelih_natparams)
ARGS = {
"in_natparams": in_natparams,
"current_natparams": current_natparams,
}
- 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 tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| smooth_leaky_relu |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("ebfa3fb00b69734e") 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 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 jax.numpy as jnp
import numpy as np
# Create a small input array for testing
x_input = jnp.array([[-2.0, -1.0, 0.0, 1.0],
[2.0, -0.5, 0.5, 3.0]])
# Create ARGS dict with all parameters
ARGS = {
"x": x_input,
"alpha": 0.1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy — 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
|
| tree_append |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("fe759f4f6da2c3c8") 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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import jax.numpy as jnp
from jax.tree_util import tree_map
# Create a simple tree structure with JAX arrays
# The function uses tree_map to vstack arrays, so we need:
# - tree: a pytree of arrays
# - app: a pytree with the same structure, containing single elements to append
# Create the tree (a dict of jax arrays)
tree = {
'a': jnp.array([[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]]),
'b': jnp.array([[9.0, 10.0, 11.0, 12.0],
[13.0, 14.0, 15.0, 16.0]])
}
# Create the app (a pytree with same structure, values to append)
# Each value should be 1D array that will be expanded with [None] to 2D
app = {
'a': jnp.array([17.0, 18.0, 19.0, 20.0]),
'b': jnp.array([21.0, 22.0, 23.0, 24.0])
}
ARGS = {
'tree': tree,
'app': app
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| tree_get_idx |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("f6bd3c01a40ce163") 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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from jax.tree_util import tree_map
torch.manual_seed(0)
# tree_get_idx indexes into the first dimension of each leaf in a tree structure
# The function uses tree_map to apply indexing to each leaf
# We need to construct a tree (nested structure) where each leaf is indexable
# Create a simple tree with multiple leaves that can be indexed
tree = (
torch.randn(2, 4), # batch size 2, feature dim 4
torch.randn(2, 3), # batch size 2, feature dim 3
{
'a': torch.randn(2, 5), # batch size 2, feature dim 5
'b': np.array([[1, 2], [3, 4]]) # batch size 2, 2 features
}
)
# idx should be a valid index into the first dimension (0 or 1 for batch size 2)
idx = 0
ARGS = {
'idx': idx,
'tree': tree
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| tree_sum |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("1cd05211b1ce4504") 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 dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from jax import numpy as jnp
torch.manual_seed(0)
# tree_sum takes a single parameter 'trees' which should be a sequence of pytrees
# The function uses tree_map to apply sum across corresponding leaves in all trees
# So we need to construct multiple pytrees with the same structure
# Create simple pytrees as nested dicts/lists with numeric leaves
tree1 = {
'a': jnp.array([1.0, 2.0, 3.0, 4.0]),
'b': {
'c': jnp.array([5.0, 6.0]),
'd': jnp.array([7.0])
}
}
tree2 = {
'a': jnp.array([10.0, 20.0, 30.0, 40.0]),
'b': {
'c': jnp.array([50.0, 60.0]),
'd': jnp.array([70.0])
}
}
tree3 = {
'a': jnp.array([100.0, 200.0, 300.0, 400.0]),
'b': {
'c': jnp.array([500.0, 600.0]),
'd': jnp.array([700.0])
}
}
trees = [tree1, tree2, tree3]
ARGS = {
'trees': trees
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| xtanh |
Ran ran; our contract draft was wrong, not the code |
HHalva/snica/elbo.py code served (permissive licence) · get_code("bf6462168e033e6d") 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 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 jax.numpy as jnp
# The function xtanh takes a single parameter 'slope' and returns a lambda function
# that computes tanh(x) + slope * x
# slope should be a numeric value (int or float)
slope_value = 0.5
ARGS = {
"slope": slope_value
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- jax — 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
|
| ELBO |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("008d5ead359cd289") How it ran |
| E_logp_lds |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("73c36837acec9c07") How it ran |
| E_sampling_likelihood |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("abcca760a8b9bffd") How it ran |
| KL_qp_u |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("34dd9aea8dfe1dea") How it ran |
| get_E_likelihood_natparams |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("b5c2dff1a83e8716") How it ran |
| get_E_transition_natparams |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("2a710b76b480eadb") How it ran |
| get_rhos |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("5afecf513378b879") How it ran |
| hmm_fwd_pass |
Not yet run unverified (harvested, no recorded run) |
hhalva/snica/inference.py code served (permissive licence) · get_code("d27a5bd4f312d0c6") How it ranno invocation recorded. this sample carries JSON test cases instead of a setup block; get_reference_implementation serves them with the level they back. |
| hmm_inference |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("abad4f61efdff92b") How it ran |
| lds_inference |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("0f64596cf7d137f3") How it ran |
| make_inference |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("6adacd6aa8068327") How it ran |
| pw_posterior |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("2f168938125038fa") How it ran |
| sample_forward |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("f362d4d0204d9525") How it ran |
| sample_fwd_step |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("d438fb20e0185ad4") How it ran |
| tree_dropfirst |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("ce7d10e8391b2340") How it ran |
| tree_droplast |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("340359eb9839e338") How it ran |
| tree_prepend |
Not yet run unverified (harvested, no recorded run) |
HHalva/snica/elbo.py code served (permissive licence) · get_code("633e314558c273f4") How it ran |