SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2407.19115 · NeurIPS · 2024

Towards Scalable and Stable Parallelization of Nonlinear RNNs

Scott Linderman, Andrew Warrington, Xavier Gonzalez, Jimmy Smith

arXiv · PDF · Open in the Atlas

Code that ran

12 of 17 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; 3 honoured the contract we drafted, 1 violated it and 0 have no contract verdict; 8 failures of our instrument; 5 no recorded run), measured 2026-11-22; 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/2407.19115.json · badge: /api/ran/2407.19115.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
lindermanlab/elk canonical (classifier label)
classifier basis: census
12 ran · 5 no recorded run
FunctionStatusWhere it lives
binary_operator Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
lindermanlab/elk/elk/models/ssm.py
code served (permissive licence) · get_code("cc57db8369c5d5df")
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, 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
import jax.numpy as jnp

# Set seed for reproducibility
import numpy as np
np.random.seed(0)

# Create small test data for the binary operator
# q_i and q_j are tuples of (A, Bu) where each has shape (P,)
# P is the dimension parameter

P = 4  # Small dimension

# Create sample q_i: tuple of (A_i, Bu_i)
A_i = jnp.array([0.5, 0.6, 0.7, 0.8], dtype=jnp.float32)
Bu_i = jnp.array([0.1, 0.2, 0.3, 0.4], dtype=jnp.float32)
q_i = (A_i, Bu_i)

# Create sample q_j: tuple of (A_j, Bu_j)
A_j = jnp.array([0.9, 0.85, 0.75, 0.65], dtype=jnp.float32)
Bu_j = jnp.array([0.05, 0.15, 0.25, 0.35], dtype=jnp.float32)
q_j = (A_j, Bu_j)

ARGS = {
    "q_i": q_i,
    "q_j": q_j,
}
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, 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
discretize_bilinear Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/models/ssm.py
code served (permissive licence) · get_code("9d8d1d6e66ab0b5b")
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.numpy as jnp
import numpy as np

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

# Define dimensions
P = 4  # number of state dimensions
H = 3  # hidden/output dimension

# Create Lambda: diagonal state matrix (P,)
# Use complex values for the diagonal elements
Lambda = jnp.array([
    -0.5 + 0.3j,
    -0.2 + 0.8j,
    -0.7 + 0.1j,
    -0.3 + 0.5j
], dtype=jnp.complex64)

# Create B_tilde: input matrix (P, H)
# Use small complex values
B_tilde = jnp.array([
    [0.1 + 0.05j, 0.2 + 0.1j, 0.15 + 0.08j],
    [0.12 + 0.06j, 0.18 + 0.09j, 0.11 + 0.07j],
    [0.14 + 0.07j, 0.16 + 0.08j, 0.13 + 0.06j],
    [0.11 + 0.05j, 0.19 + 0.1j, 0.14 + 0.07j]
], dtype=jnp.complex64)

# Create Delta: discretization step sizes (P,)
# Use small positive floats
Delta = jnp.array([0.01, 0.02, 0.015, 0.025], dtype=jnp.float32)

ARGS = {
    "Lambda": Lambda,
    "B_tilde": B_tilde,
    "Delta": Delta
}
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
discretize_zoh Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/models/ssm.py
code served (permissive licence) · get_code("da7a8a4afbf9a53f")
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.numpy as jnp
import numpy as np

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

# Define small test dimensions
P = 4  # state dimension
H = 3  # hidden/input dimension

# Create Lambda: diagonal state matrix (P,) as complex64
Lambda = jnp.array(
    np.random.randn(P) + 1j * np.random.randn(P),
    dtype=jnp.complex64
)

# Create B_tilde: input matrix (P, H) as complex64
B_tilde = jnp.array(
    np.random.randn(P, H) + 1j * np.random.randn(P, H),
    dtype=jnp.complex64
)

# Create Delta: discretization step sizes (P,) as float32
Delta = jnp.array(
    np.abs(np.random.randn(P)) * 0.1,
    dtype=jnp.float32
)

ARGS = {
    "Lambda": Lambda,
    "B_tilde": B_tilde,
    "Delta": Delta,
}
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
make_DPLR_HiPPO Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/models/ssm_init.py
code served (permissive licence) · get_code("ccbe2ce2b6220758")
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.numpy as jnp
from jax.numpy.linalg import eigh

def make_HiPPO(N):
    """Create a HiPPO-LegS matrix.
    From https://github.com/srush/annotated-s4/blob/main/s4/s4.py
    Args:
        N (int32): state size
    Returns:
        N x N HiPPO LegS matrix
    """
    P = jnp.sqrt(1 + 2 * jnp.arange(N))
    A = P[:, jnp.newaxis] * P[jnp.newaxis, :]
    A = jnp.tril(A) - jnp.diag(jnp.arange(N))
    return -A

def make_NPLR_HiPPO(N):
    """
    Makes components needed for NPLR representation of HiPPO-LegS
     From https://github.com/srush/annotated-s4/blob/main/s4/s4.py
    Args:
        N (int32): state size

    Returns:
        N x N HiPPO LegS matrix, low-rank factor P, HiPPO input matrix B

    """
    hippo = make_HiPPO(N)
    P = jnp.sqrt(jnp.arange(N) + 0.5)
    B = jnp.sqrt(2 * jnp.arange(N) + 1.0)
    return (hippo, P, B)

def make_DPLR_HiPPO(N):
    """
    Makes components needed for DPLR representation of HiPPO-LegS
     From https://github.com/srush/annotated-s4/blob/main/s4/s4.py
    Note, we will only use the diagonal part
    Args:
        N: (state size)

    Returns:
        eigenvalues Lambda, low-rank term P, conjugated HiPPO input matrix B,
        eigenvectors V, HiPPO B pre-conjugation

    """
    A, P, B = make_NPLR_HiPPO(N)
    S = A + P[:, jnp.newaxis] * P[jnp.newaxis, :]
    S_diag = jnp.diagonal(S)
    Lambda_real = jnp.mean(S_diag) * jnp.ones_like(S_diag)
    Lambda_imag, V = eigh(S * -1j)
    P = V.conj().T @ P
    B_orig = B
    B = V.conj().T @ B
    return (Lambda_real + 1j * Lambda_imag, P, B, V, B_orig)

ARGS = {
    "N": 4,
}
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 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
make_HiPPO Ran
ran, honoured the contract we drafted
lindermanlab/elk/elk/models/ssm_init.py
code served (permissive licence) · get_code("270b83f06c0fa675")
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.numpy as jnp

# The function make_HiPPO takes a single parameter N which should be an integer
# representing the state size. The function constructs a HiPPO-LegS matrix by:
# 1. Creating a vector P of size N
# 2. Computing outer products and matrix operations
# 3. Returning an N x N matrix

# For testing, we'll use a small state size
N = 4

ARGS = {
    "N": N
}
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
make_NPLR_HiPPO Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/models/ssm_init.py
code served (permissive licence) · get_code("b7812ff1a3838617")
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.numpy as jnp

# Examine the function signature and body:
# make_NPLR_HiPPO(N) takes a single parameter N which is an int32 representing state size
# The function uses N in jnp operations to create arrays and matrices

# N should be a small positive integer for testing
N = 4

ARGS = {
    "N": N,
}
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 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
make_scalar_params Ran
ran, honoured the contract we drafted
lindermanlab/elk/elk/utils/parallel_kalman_scalar.py
code served (permissive licence) · get_code("5ed5fad0395e9de2")
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 ScalarParams. 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)

# Define dimensions
state_dim = 4
ntime = 3

# Create tensors with appropriate shapes
initial_mean = torch.randn(state_dim)
dynamics_weights = torch.randn(ntime, state_dim)
dynamics_bias = torch.randn(ntime, state_dim)
emission_noises = torch.randn(ntime, state_dim)

ARGS = {
    'initial_mean': initial_mean,
    'dynamics_weights': dynamics_weights,
    'dynamics_bias': dynamics_bias,
    'emission_noises': emission_noises,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jaxtyping, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ScalarParams — a ScalarParams 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
make_unpacking_tuple Ran
ran, honoured the contract we drafted
lindermanlab/elk/elk/utils/elk_utils.py
code served (permissive licence) · get_code("139ecb120bda617a")
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, ndim 1, dtype family int; 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

class SSM:
    def __init__(self, P):
        self.P = P

class SeqModel:
    def __init__(self, P, n_layers):
        self.ssm = SSM(P)
        self.n_layers = n_layers

class Conditioner:
    def __init__(self, P, n_layers):
        self.seq_model = SeqModel(P, n_layers)

class ChainedAF:
    def __init__(self, P, n_layers):
        self.conditioners = [Conditioner(P, n_layers)]

# Create model with specific dimensions
P = 5  # distinct value for state dimension
n_layers = 3  # distinct value for number of layers

model = ChainedAF(P, n_layers)

ARGS = {
    "model": model
}
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, ndim 1, dtype family int — 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
rectify Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
lindermanlab/elk/elk/models/model_utils.py
code served (permissive licence) · get_code("40b10cbf8006f1b1")
How it ran

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

import jax.numpy as jnp
import jax.nn as jnn

# Create a small log_scale array
log_scale = jnp.array([0.1, 0.2, -0.1, 0.3])

# Test with softplus=True
ARGS = {
    "log_scale": log_scale,
    "softplus": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sample_AR_many_layers Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/models/model_utils.py
code served (permissive licence) · get_code("08adf88d4235a6af")
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 jax.random as jr
import jax.nn as jnn


class SimpleSSM:
    def __init__(self, P):
        self.P = P
        self.x0 = jnp.zeros(P, dtype=jnp.complex64)


class SimpleLayer:
    def __init__(self, P):
        self.ssm = SimpleSSM(P)


class SimpleSeqModel:
    def __init__(self, P, n_layers):
        self.P = P
        self.n_layers = n_layers
        self.ssm = SimpleSSM(P)
        self.layers = [SimpleLayer(P) for _ in range(n_layers)]
    
    def single_step(self, h_minus_ones, x, no_encode=False):
        # Returns (h0, output)
        # h0 is a list of hidden states, one per layer
        # output is the final output
        h0 = [jnp.zeros(self.P, dtype=jnp.complex64) for _ in range(self.n_layers)]
        output = jnp.zeros(self.P, dtype=jnp.complex64)
        return h0, output


class SimpleDecoder:
    def __init__(self, P):
        self.P = P
    
    def __call__(self, output):
        # Returns (mu, log_scale)
        mu = jnp.zeros(1, dtype=jnp.complex64)
        log_scale = jnp.zeros(1, dtype=jnp.complex64)
        return mu, log_scale


class SimpleFlowModel:
    def __init__(self, P, n_layers):
        self.P = P
        self.n_layers = n_layers
        self.seq_model = SimpleSeqModel(P, n_layers)
        self.decoder = SimpleDecoder(P)


class SimpleConditioner:
    def __init__(self, P, n_layers):
        self.seq_model = SimpleSeqModel(P, n_layers)
        self.decoder = SimpleDecoder(P)


class SimpleModel:
    def __init__(self, P, n_layers):
        self.P = P
        self.n_layers = n_layers
        self.conditioners = [SimpleConditioner(P, n_layers)]
        self.softplus = True


P = 4
n_layers = 2
model = SimpleModel(P, n_layers)
length = 5
key = jr.PRNGKey(0)
dtype = jnp.complex64

ARGS = {
    "model": model,
    "length": length,
    "key": key,
    "dtype": dtype,
}
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 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
str2bool Ran
ran, violated the contract we drafted
lindermanlab/elk/elk/models/model_utils.py
code served (permissive licence) · get_code("7c508037b40522af")
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 bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import argparse

def str2bool(v):
    if isinstance(v, bool):
        return v
    if v.lower() in ('yes', 'true', 't', 'y', '1'):
        return True
    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
        return False
    else:
        raise argparse.ArgumentTypeError('Boolean value expected.')

# Test cases for str2bool
ARGS = {
    'v': 'true'  # string input that should convert to boolean
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unpack_state Ran
ran; our contract draft was wrong, not the code
lindermanlab/elk/elk/utils/elk_utils.py
code served (permissive licence) · get_code("f014c636df2c771c")
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.numpy as jnp
import numpy as np

# Create a packed state as a JAX array
# The function will split this according to unpacking_tuple
packed_state = jnp.array([1.0 + 2.0j, 3.0 + 4.0j, 5.0 + 6.0j, 7.0 + 8.0j, 9.0 + 10.0j, 11.0 + 12.0j], dtype=jnp.complex64)

# unpacking_tuple should be a tuple of indices for jnp.split
# jnp.split(array, indices_or_sections) splits the array
# If unpacking_tuple is [2, 4], it splits at indices 2 and 4
# This creates: output (x) of size 2, then hidden states of sizes 2 and 2
unpacking_tuple = [2, 4]

ARGS = {
    "unpacking_tuple": unpacking_tuple,
    "packed_state": packed_state,
}
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
deer_iteration Not yet run
unverified (harvested, no recorded run)
lindermanlab/elk/elk/algs/deer.py
code served (permissive licence) · get_code("7b98e2132b6ba6ee")
How it ran

no invocation recorded.

deer_iteration_eval Not yet run
unverified (harvested, no recorded run)
lindermanlab/elk/elk/algs/deer.py
code served (permissive licence) · get_code("9c7863de7bd3644d")
How it ran

no invocation recorded.

pack_state Not yet run
unverified (harvested, no recorded run)
lindermanlab/elk/elk/utils/elk_utils.py
code served (permissive licence) · get_code("51e5bbc3d32e269a")
How it ran

no invocation recorded.

parallel_scalar_filter Not yet run
unverified (harvested, no recorded run)
lindermanlab/elk/elk/utils/parallel_kalman_scalar.py
code served (permissive licence) · get_code("a9ec88fdd23680bc")
How it ran

no invocation recorded.

seq1d Not yet run
unverified (harvested, no recorded run)
lindermanlab/elk/elk/algs/deer.py
code served (permissive licence) · get_code("e76d4d34c46d65cd")
How it ran

no invocation recorded.

Also present in other papers' code

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

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

FunctionAlso present inEarliest-datedOthers named
str2bool 175 other papers
128 dated earlier, 3 the same month, 43 later, 1 same year, order not determinable · 2 only as an assembly brick
1406.6247 (2014-06)
Recurrent Models of Visual Attention
1603.09382 (2016-03)
Deep Networks with Stochastic Depth
1710.10196 (2017-10)
Progressive Growing of GANs for Improved Quality, Stability, and Variation
and 172 more not named here
binary_operator 4 other papers
2 dated earlier, 2 later
2208.04933 (2022-08)
Simplified State Space Layers for Sequence Modeling
2402.15584 (2024-02)
State Space Models for Event Cameras
2411.02824 (2024-11)
Layer-Adaptive State Pruning for Deep State Space Models
and 1 more not named here

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

Repositories linked to this paper

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

Abstract

Transformers and linear state space models can be evaluated in parallel on modern hardware, but evaluating nonlinear RNNs appears to be an inherently sequential problem. Recently, however, Lim et al. [1] developed an approach called DEER, which evaluates nonlinear RNNs in parallel by posing the states as the solution to a fixed-point problem. They derived a parallel form of Newton's method to solve the fixed-point problem and achieved significant speedups over sequential evaluation. However, the computational complexity of DEER is cubic in the state size, and the algorithm can suffer from numerical instability. We address these limitations with two novel contributions. To reduce the computational complexity, we apply quasi-Newton approximations and show they converge comparably to Newton, use less memory, and are faster. To stabilize DEER, we leverage a connection between the Levenberg-Marquardt algorithm and Kalman smoothing, which we call ELK. This connection allows us to stabilize Newton's method while using efficient parallelized Kalman smoothing algorithms to retain performance. Through several experiments, we show that these innovations allow for parallel evaluation of nonlinear RNNs at larger scales and with greater stability.

For agents

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

get_harvested_code_for_paper("2407.19115")
get_code_for_paper("2407.19115")
have("2407.19115")

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

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

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

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

Connect an agent — have() is free.