SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2106.09620 · NeurIPS · 2021

Disentangling Identifiable Features from Noisy Data with Structured Nonlinear ICA

Aapo Hyvärinen, Hermanni Hälvä, Sylvain Le Corff, Luc Lehéricy, Jonathan So, Yongjie Zhu, Elisabeth Gassiat

arXiv · PDF · Open in the Atlas

Code that ran

23 of 40 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 1 violated it and 0 have no contract verdict; 18 failures of our instrument; 17 no recorded run), measured 2026-11-21; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2106.09620.json · badge: /api/ran/2106.09620.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
hhalva/snica canonical (classifier label)
classifier basis: classifier_2025
2 ran · 1 no recorded run
HHalva/snica marked official in Papers with Code
Papers with Code archive
21 ran · 16 no recorded run
FunctionStatusWhere it lives
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

get_rhos Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("5afecf513378b879")
How it ran

no invocation recorded.

hmm_fwd_pass Not yet run
unverified (harvested, no recorded run)
hhalva/snica/inference.py
code served (permissive licence) · get_code("d27a5bd4f312d0c6")
How it ran

no 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

no invocation recorded.

lds_inference Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("0f64596cf7d137f3")
How it ran

no invocation recorded.

make_inference Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("6adacd6aa8068327")
How it ran

no invocation recorded.

pw_posterior Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("2f168938125038fa")
How it ran

no invocation recorded.

sample_forward Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("f362d4d0204d9525")
How it ran

no invocation recorded.

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

no invocation recorded.

tree_dropfirst Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("ce7d10e8391b2340")
How it ran

no invocation recorded.

tree_droplast Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("340359eb9839e338")
How it ran

no invocation recorded.

tree_prepend Not yet run
unverified (harvested, no recorded run)
HHalva/snica/elbo.py
code served (permissive licence) · get_code("633e314558c273f4")
How it ran

no invocation recorded.

Also present in other papers' code

Of 40 samples lifted from this paper's linked repositories, 40 carry a function identity and 0 do not. Of the 40 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 40 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-21.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We introduce a new general identifiable framework for principled disentanglement referred to as Structured Nonlinear Independent Component Analysis (SNICA). Our contribution is to extend the identifiability theory of deep generative models for a very broad class of structured models. While previous works have shown identifiability for specific classes of time-series models, our theorems extend this to more general temporal structures as well as to models with more complex structures such as spatial dependencies. In particular, we establish the major result that identifiability for this framework holds even in the presence of noise of unknown distribution. Finally, as an example of our framework's flexibility, we introduce the first nonlinear ICA model for time-series that combines the following very useful properties: it accounts for both nonstationarity and autocorrelation in a fully unsupervised setting; performs dimensionality reduction; models hidden states; and enables principled estimation and inference by variational maximum-likelihood.

For agents

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

get_harvested_code_for_paper("2106.09620")
get_code_for_paper("2106.09620")
have("2106.09620")

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

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

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

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

Connect an agent — have() is free.