SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2502.19611 · ICLR · 2025

PRDP: Progressively Refined Differentiable Physics

Nils Thuerey, Felix Koehler, Kanishk Bhatia

arXiv · PDF · Open in the Atlas

Code that ran

8 of 9 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (3 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 6 have no contract verdict; 1 failure of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; 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/2502.19611.json · badge: /api/ran/2502.19611.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
tum-pbs/prdp canonical (classifier label)
classifier basis: classifier_2025
8 ran · 1 no recorded run
FunctionStatusWhere it lives
BaseLinSolve Ran
ran on a synthesized input · constructed an object; no result was computed
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("bbf8d385e1724526")
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 an instance of its own class, BaseLinSolve: the run constructed the object and did not call it, so no result was computed. 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 equinox as eqx

torch.manual_seed(0)

# BaseLinSolve is a bare eqx.Module with no explicit __init__ parameters
# We need to inspect what parameters it might accept through inheritance
# Since it's just `pass`, it inherits from eqx.Module which is a pytree container

# Create ARGS dict for BaseLinSolve instantiation
# Since BaseLinSolve has no explicit parameters, we pass empty dict
ARGS = {}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
equinox, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type BaseLinSolve — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BaseLinSolve 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
BiCG_Stab_Solve Ran
ran on a synthesized input · constructed an object; no result was computed
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("7ddfa113c04c4320")
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 an instance of its own class, BiCG_Stab_Solve: the run constructed the object and did not call it, so no result was computed. 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 equinox as eqx
from typing import Optional

TOL = 1e-05

class BaseLinSolve(eqx.Module):
    pass

class BiCG_Stab_Solve(BaseLinSolve):
    maxiter: Optional[int] = None

    def __call__(self, lin_fun, rhs):
        x, _ = jax.scipy.sparse.linalg.bicgstab(lin_fun, rhs, maxiter=self.maxiter, tol=TOL)
        return x

    def diagnose(self, lin_fun, rhs, maxiter=None):
        """ Return all iterates of the BiCG_Stab algorithm."""
        if maxiter is None:
            maxiter = self.maxiter
        x_history = None
        return x_history

def create_lin_fun():
    """Create a simple linear operator that applies a matrix multiplication."""
    A = jnp.array([[2.0, 0.5, 0.1, 0.0],
                    [0.5, 3.0, 0.2, 0.1],
                    [0.1, 0.2, 2.5, 0.3],
                    [0.0, 0.1, 0.3, 2.0]])
    
    def lin_fun(x):
        return A @ x
    
    return lin_fun

def create_rhs():
    """Create a small right-hand side vector."""
    rhs = jnp.array([1.0, 2.0, 3.0, 4.0])
    return rhs

lin_fun = create_lin_fun()
rhs = create_rhs()

ARGS = {
    "maxiter": 10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
equinox, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type BiCG_Stab_Solve — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BiCG_Stab_Solve 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
CG_Solve Ran
ran on a synthesized input
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("607952c36f464e23")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned ArrayImpl, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import equinox as eqx
from typing import Optional

TOL = 1e-05

class BaseLinSolve(eqx.Module):
    pass

class CG_Solve(BaseLinSolve):
    maxiter: Optional[int] = None

    def __call__(self, lin_fun, rhs):
        x, _ = jax.scipy.sparse.linalg.cg(lin_fun, rhs, maxiter=self.maxiter, tol=TOL)
        return x

    def diagnose(self, lin_fun, rhs):
        raise NotImplementedError('jax.scipy.sparse.linalg.cg does not support diagnostics.')


INIT_ARGS = {
    'maxiter': 100
}

ARGS = {
    'lin_fun': lambda x: jnp.dot(jnp.array([[2.0, 0.5], [0.5, 1.0]]), x),
    'rhs': jnp.array([1.0, 2.0])
}

if __name__ == '__main__':
    solver = CG_Solve(**INIT_ARGS)
    result = solver(**ARGS)
    print("Solution:", result)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
equinox, 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Direct_Solve Ran
ran on a synthesized input
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("d47a644c3a8113e2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned ArrayImpl, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import equinox as eqx
from jax import jacfwd

class BaseLinSolve(eqx.Module):
    pass

class Direct_Solve(BaseLinSolve):

    def __call__(self, lin_fun, rhs):
        return_shape = rhs.shape
        matrix = jacfwd(lin_fun)(jnp.zeros(rhs.shape))
        rhs = rhs.flatten()
        matrix = matrix.reshape((rhs.size, rhs.size))
        x = jax.scipy.linalg.solve(matrix, rhs)
        return x.reshape(return_shape)


INIT_ARGS = {}

def create_lin_fun():
    def lin_fun(x):
        return 2.0 * x + 0.5
    return lin_fun

ARGS = {
    'lin_fun': create_lin_fun(),
    'rhs': jnp.array([1.0, 2.0, 3.0, 4.0])
}

if __name__ == '__main__':
    solver = Direct_Solve(**INIT_ARGS)
    result = solver(**ARGS)
    print("Result shape:", result.shape)
    print("Result:", result)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
equinox, 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
GMRES_Solve Ran
ran on a synthesized input
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("ca413bbe2237c917")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned ArrayImpl, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import numpy as np

# Create a simple linear function for testing
# We'll solve A @ x = b where A is represented by lin_fun
def create_linear_operator(matrix):
    """Returns a function that applies the matrix to a vector."""
    def lin_fun(x):
        return matrix @ x
    return lin_fun

# Set up a small linear system
n = 5
np.random.seed(42)
A_np = np.random.randn(n, n).astype(np.float32)
# Make it symmetric positive definite to ensure convergence
A_np = A_np @ A_np.T + np.eye(n) * 0.1
b_np = np.random.randn(n).astype(np.float32)

# Convert to JAX arrays
A_jax = jnp.array(A_np)
b_jax = jnp.array(b_np)

# Create the linear operator
lin_fun = create_linear_operator(A_jax)

INIT_ARGS = {
    'maxiter': 10,
    'restart': 5,
    'solve_method': 'batched'
}

ARGS = {
    'lin_fun': lin_fun,
    'rhs': b_jax
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
equinox, 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 1, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
PicardStepper Ran
ran on a synthesized input · constructed an object; no result was computed
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("516e528c24079fa9")
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 an instance of its own class, PicardStepper: the run constructed the object and did not call it, so no result was computed. 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 equinox as eqx
from typing import Optional

# Define TOL as it's used in the module
TOL = 1e-05

# Define minimal versions of the solver classes
class BaseLinSolve(eqx.Module):
    pass

class GMRES_Solve(BaseLinSolve):
    maxiter: Optional[int] = None
    restart: int = 20
    solve_method: str = 'batched'

    def __call__(self, lin_fun, rhs):
        x, _ = jax.scipy.sparse.linalg.gmres(lin_fun, rhs, maxiter=self.maxiter, solve_method=self.solve_method, tol=TOL, restart=self.restart)
        return x

class CG_Solve(BaseLinSolve):
    maxiter: Optional[int] = None

    def __call__(self, lin_fun, rhs):
        x, _ = jax.scipy.sparse.linalg.cg(lin_fun, rhs, maxiter=self.maxiter, tol=TOL)
        return x

class BiCG_Stab_Solve(BaseLinSolve):
    maxiter: Optional[int] = None

    def __call__(self, lin_fun, rhs):
        x, _ = jax.scipy.sparse.linalg.bicgstab(lin_fun, rhs, maxiter=self.maxiter, tol=TOL)
        return x

class Direct_Solve(BaseLinSolve):

    def __call__(self, lin_fun, rhs):
        return_shape = rhs.shape
        matrix = jax.jacfwd(lin_fun)(jnp.zeros(rhs.shape))
        rhs_flat = rhs.flatten()
        matrix = matrix.reshape((rhs_flat.size, rhs_flat.size))
        x = jax.scipy.linalg.solve(matrix, rhs_flat)
        return x.reshape(return_shape)

class PicardStepper(eqx.Module):
    use_acceleration: bool
    maxiter_picard: int
    _maxiter: int
    maxiter_linsolve: int
    adjoint_method: str
    _unrolled_diff: bool
    linsolve: BaseLinSolve

    def __init__(self, *, use_acceleration: bool=False, maxiter_picard: int=100, maxiter_linsolve: int=100, solver: str='gmres', restart: int=20, adjoint_method: str='full'):
        self.use_acceleration = use_acceleration
        self.maxiter_picard = maxiter_picard
        self._maxiter = maxiter_picard
        self.maxiter_linsolve = maxiter_linsolve
        self.adjoint_method = adjoint_method
        self._unrolled_diff = (adjoint_method == 'unrolled')
        
        if solver == 'gmres':
            self.linsolve = GMRES_Solve(maxiter=maxiter_linsolve, restart=restart)
        elif solver == 'cg':
            self.linsolve = CG_Solve(maxiter=maxiter_linsolve)
        elif solver == 'bicgstab':
            self.linsolve = BiCG_Stab_Solve(maxiter=maxiter_linsolve)
        elif solver == 'direct':
            self.linsolve = Direct_Solve()
        else:
            raise ValueError(f"Unknown solver: {solver}")

# Create ARGS dictionary with all required parameters
ARGS = {
    'use_acceleration': False,
    'maxiter_picard': 50,
    'maxiter_linsolve': 30,
    'solver': 'gmres',
    'restart': 15,
    'adjoint_method': 'full'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
equinox, jax, jaxopt — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PicardStepper — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PicardStepper 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
numpy_ewma Ran
ran, honoured the contract we drafted
tum-pbs/prdp/experiments/src/prdp.py
code served (permissive licence) · get_code("ba36c22fafe97643")
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 ndarray, ndim 1, dtype family float, shape (5,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small numpy array for the data parameter
data = np.array([1.0, 2.0, 3.0, 4.0, 5.0])

# Create a window size parameter
window = 3

ARGS = {
    "data": data,
    "window": window,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (5,) — shape (5,) 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
should_refine Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
tum-pbs/prdp/experiments/src/prdp.py
code served (permissive licence) · get_code("6d023282f18197aa")
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 numpy as np

# Initialize the error_checkpoint attribute that the function uses
def should_refine(error_hist, stepping_threshold=0.98, nmax_threshold=0.9, ema_window=6, error_window=3):
    """
    Check if error history has plateued.
    If True, check if it has also plateaued w.r.t. error_checkpoint.
    """
    if len(error_hist) <= error_window:
        return False
    error_ema = numpy_ewma(np.array(error_hist).flatten(), window=ema_window)
    error_ratio = error_ema[-1] / error_ema[-error_window]
    print(f'error ratio = {error_ratio}')
    if error_ratio > stepping_threshold:
        checkpoint_ratio = error_ema[-1] / should_refine.error_checkpoint
        print(f'checkpoint ratio = {checkpoint_ratio}')
        if checkpoint_ratio < nmax_threshold or checkpoint_ratio > 1:
            should_refine.error_checkpoint = error_ema[-1]
            return True
        else:
            return False
    else:
        return False

def numpy_ewma(data, window):
    """
    Return exponential moving average of the data.
    Source: https://stackoverflow.com/a/42926270/16413425
    """
    alpha = 2 / (window + 1.0)
    alpha_rev = 1 - alpha
    n = data.shape[0]
    pows = alpha_rev ** np.arange(n + 1)
    scale_arr = 1 / pows[:-1]
    offset = data[0] * pows[1:]
    pw0 = alpha * alpha_rev ** (n - 1)
    mult = data * pw0 * scale_arr
    cumsums = mult.cumsum()
    out = offset + cumsums * scale_arr[::-1]
    return out

# Initialize the error_checkpoint as a function attribute
should_refine.error_checkpoint = 0.5

# Create error history with enough values to pass the length check
# and create a scenario where error_ratio > stepping_threshold
error_hist = [0.8, 0.75, 0.72, 0.71, 0.70, 0.69, 0.68, 0.67, 0.66, 0.65]

ARGS = {
    "error_hist": error_hist,
    "stepping_threshold": 0.98,
    "nmax_threshold": 0.9,
    "ema_window": 6,
    "error_window": 3,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
ImplicitTimeStepper Not yet run
unverified (harvested, no recorded run)
tum-pbs/prdp/experiments/src/implicax/implicax/implicit_time_stepper.py
code served (permissive licence) · get_code("d5a02087b7a4d53d")
How it ran

no invocation recorded.

Also present in other papers' code

Of 9 samples lifted from this paper's linked repositories, 9 carry a function identity and 0 do not. Of the 9 distinct functions with an identity, 2 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 2 later) and 7 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
numpy_ewma 1 other paper
1 later
2608.24547 (2026-08)
From Numerical Simulators of PDEs to Neural Emulators and Back
should_refine 1 other paper
1 later
2608.24547 (2026-08)
From Numerical Simulators of PDEs to Neural Emulators and Back

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

The physics solvers employed for neural network training are primarily iterative, and hence, differentiating through them introduces a severe computational burden as iterations grow large. Inspired by works in bilevel optimization, we show that full accuracy of the network is achievable through physics significantly coarser than fully converged solvers. We propose progressively refined differentiable physics (PRDP), an approach that identifies the level of physics refinement sufficient for full training accuracy. By beginning with coarse physics, adaptively refining it during training, and stopping refinement at the level adequate for training, it enables significant compute savings without sacrificing network accuracy. Our focus is on differentiating iterative linear solvers for sparsely discretized differential operators, which are fundamental to scientific computing. PRDP is applicable to both unrolled and implicit differentiation. We validate its performance on a variety of learning scenarios involving differentiable physics solvers such as inverse problems, autoregressive neural emulators, and correction-based neuralhybrid solvers. In the challenging example of emulating the Navier-Stokes equations, we reduce training time by 62%.

For agents

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

get_harvested_code_for_paper("2502.19611")
get_code_for_paper("2502.19611")
have("2502.19611")

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

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

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

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

Connect an agent — have() is free.