SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2106.04692 · NeurIPS · 2021

Provably Faster Algorithms for Bilevel Optimization

Yingbin Liang, Kaiyi Ji, Junjie Yang

arXiv · PDF · Open in the Atlas

Code that ran

8 of 10 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; 2 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 6 failures of our instrument; 2 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/2106.04692.json · badge: /api/ran/2106.04692.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
junjieyang97/mrvrbo canonical (classifier label)
classifier basis: classifier_2025
6 ran · 2 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
JunjieYang97/MRVRBO marked official in Papers with Code
Papers with Code archive
1 ran · 0 no recorded run
FunctionStatusWhere it lives
cat_list_to_tensor Ran
ran, honoured the contract we drafted
junjieyang97/mrvrbo/hypergrad/CG_torch.py
code served (permissive licence) · get_code("3ed1406329714c3f")
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 Tensor, ndim 1, dtype family float, shape (29,) 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 torch

torch.manual_seed(0)

# The function expects list_tx to be a list of tensors
# It flattens each tensor and concatenates them
list_tx = [
    torch.randn(2, 4),      # First tensor: shape (2, 4)
    torch.randn(3, 5),      # Second tensor: shape (3, 5)
    torch.randn(6),         # Third tensor: shape (6,)
]

ARGS = {
    "list_tx": list_tx,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (29,) — shape (29,) 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
cg Ran
ran; our contract draft was wrong, not the code
junjieyang97/mrvrbo/hypergrad/CG_torch.py
code served (permissive licence) · get_code("31f282d2a7c181bb")
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 list. 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

torch.manual_seed(0)

# Define a simple linear operator function that takes a list of tensors
# and returns a list of tensors (simulating matrix-vector multiplication)
def linear_operator(x_list):
    """
    Simple linear operator: Ax where A is a small matrix.
    Takes list of tensors, returns list of tensors.
    """
    result = []
    for x in x_list:
        # Simple operation: multiply by 2 (acts like a diagonal matrix)
        result.append(2.0 * x)
    return result

# Create the b vector as a list of small tensors
b = [
    torch.randn(4),
    torch.randn(3),
]

ARGS = {
    "Ax": linear_operator,
    "b": b,
    "max_iter": 100,
    "epsilon": 1e-05,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list 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
fixed_point Ran
ran; our contract draft was wrong, not the code
junjieyang97/mrvrbo/hypergrad/hypergradients.py
code served (permissive licence) · get_code("11d924c279d6166a")
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 list, 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 torch
import torch.nn as nn
from typing import List, Callable

torch.manual_seed(0)

# Define a simple inner problem: minimize ||w - target||^2
def create_fp_map(target: torch.Tensor) -> Callable:
    """Creates a fixed point map for a simple quadratic problem."""
    def fp_map(params: List[torch.Tensor], hparams: List[torch.Tensor]) -> List[torch.Tensor]:
        # Simple fixed point: w_new = w - lr * (w - target)
        # where lr is controlled by hparams
        lr = hparams[0]
        w_new = params[0] - lr * (params[0] - target)
        return [w_new]
    return fp_map

def create_outer_loss(target: torch.Tensor) -> Callable:
    """Creates an outer loss function."""
    def outer_loss(params: List[torch.Tensor], hparams: List[torch.Tensor]) -> torch.Tensor:
        # Outer loss: ||params - target||^2
        return torch.sum((params[0] - target) ** 2)
    return outer_loss

# Set up parameters (inner loop variables)
params = [torch.randn(2, 4, requires_grad=False)]

# Set up hyperparameters (outer loop variables)
hparams = [torch.tensor(0.1, requires_grad=True)]

# Set up the fixed point map and outer loss
target = torch.randn(2, 4)
fp_map = create_fp_map(target)
outer_loss = create_outer_loss(target)

# Number of fixed point iterations
K = 5

# Tolerance for early stopping
tol = 1e-10

# Whether to set gradients on hparams
set_grad = True

# Whether the fixed point map is stochastic
stochastic = False

ARGS = {
    "params": params,
    "hparams": hparams,
    "K": K,
    "fp_map": fp_map,
    "outer_loss": outer_loss,
    "tol": tol,
    "set_grad": set_grad,
    "stochastic": stochastic,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list 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
loss_train_avg Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from JunjieYang97/stocBiO
pointer only · get_code("d46ee4443d27d233")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

mstsa Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
JunjieYang97/MRVRBO/stocBiO.py
code served (permissive licence) · get_code("2d1dc63491a58c81")
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 Tensor, ndim 1, dtype family float, shape (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 torch
import torch.nn as nn
from torch.nn import functional as F

torch.manual_seed(0)

# Define a simple model that takes data and params and produces output
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, data, params=None):
        # If params provided, use them; otherwise use model params
        if params is not None:
            return F.linear(data, params[:3*4].reshape(3, 4), params[3*4:3*4+3])
        return self.linear(data)

# Create model and extract parameters
model = SimpleModel()
params = nn.Parameter(torch.randn(3*4 + 3, requires_grad=True))
params_next = nn.Parameter(torch.randn(3*4 + 3, requires_grad=True))

# Create hyperparameters
hparams = nn.Parameter(torch.randn(2, requires_grad=True))
hparams_old = nn.Parameter(torch.randn(2, requires_grad=True))

# Define output function
def out_f(data, params):
    # Simple linear transformation
    return F.linear(data, params[:3*4].reshape(3, 4), params[3*4:3*4+3])

# Define regularization function
def reg_f(params, hparams, loss):
    # Simple regularization: sum of loss plus L2 penalty scaled by hparams
    return torch.sum(loss) + hparams[0] * torch.sum(params ** 2)

# Create validation data: 3 batches with data and labels
batch_size = 2
input_dim = 4
num_classes = 3

data_list = [
    torch.randn(batch_size, input_dim),
    torch.randn(batch_size, input_dim),
    torch.randn(batch_size, input_dim)
]

labels_list = [
    torch.randint(0, num_classes, (batch_size,)),
    torch.randint(0, num_classes, (batch_size,)),
    torch.randint(0, num_classes, (batch_size,))
]

val_data_list = (data_list, labels_list)

# Create args object with required attributes
class Args:
    def __init__(self):
        self.eta = 0.01
        self.hessian_q = 2

args = Args()

# Previous update
previous_update = torch.randn(2, requires_grad=True)

# Eta for mstsa
eta = 0.5

ARGS = {
    'prerious_update': previous_update,
    'eta': eta,
    'val_data_list': val_data_list,
    'args': args,
    'params': params,
    'params_next': params_next,
    'hparams': hparams,
    'hparams_old': hparams_old,
    'out_f': out_f,
    'reg_f': reg_f
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (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
reverse Ran
ran, honoured the contract we drafted
junjieyang97/mrvrbo/hypergrad/hypergradients.py
code served (permissive licence) · get_code("52b6f88728db5c40")
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 list, 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 torch
import torch.nn as nn
from typing import List, Callable

torch.manual_seed(0)

# Define a simple update map function that takes params and hparams and returns updated params
def simple_update_map(params: List[torch.Tensor], hparams: List[torch.Tensor]) -> List[torch.Tensor]:
    """Simple update map: w_new = w - lr * grad, where lr is a hyperparameter"""
    # Simulate a gradient step with learning rate from hparams
    lr = hparams[0]
    updated = []
    for p in params:
        # Create a dummy gradient
        dummy_grad = torch.ones_like(p) * 0.1
        updated.append(p - lr * dummy_grad)
    return updated

# Define outer loss function
def outer_loss_fn(params: List[torch.Tensor], hparams: List[torch.Tensor]) -> torch.Tensor:
    """Compute outer loss as sum of squared parameters"""
    loss = torch.tensor(0.0, requires_grad=True)
    for p in params:
        loss = loss + (p ** 2).sum()
    return loss

# Create parameter history: list of parameter snapshots at different iterations
# Each snapshot is a list of tensors
params_history = [
    [torch.randn(2, 4, requires_grad=True), torch.randn(3, 4, requires_grad=True)],
    [torch.randn(2, 4, requires_grad=True), torch.randn(3, 4, requires_grad=True)],
    [torch.randn(2, 4, requires_grad=True), torch.randn(3, 4, requires_grad=True)],
]

# Create hyperparameters (must have requires_grad=True)
hparams = [
    torch.tensor(0.01, requires_grad=True),
    torch.tensor(0.1, requires_grad=True),
]

# Create update map history: list of update functions
# One update map for each transition in params_history
update_map_history = [
    simple_update_map,
    simple_update_map,
    simple_update_map,
]

# Define outer loss function that will be called
outer_loss = outer_loss_fn

ARGS = {
    "params_history": params_history,
    "hparams": hparams,
    "update_map_history": update_map_history,
    "outer_loss": outer_loss,
    "set_grad": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list 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
reverse_unroll Ran
ran; our contract draft was wrong, not the code
junjieyang97/mrvrbo/hypergrad/hypergradients.py
code served (permissive licence) · get_code("677c8518ad1a22c9")
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
from torch import Tensor
from typing import List, Callable

torch.manual_seed(0)

# Create hyperparameters (outer variables)
# These need requires_grad=True to compute hypergradients
hparams = [
    torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True),
    torch.tensor([0.5, 1.5], requires_grad=True)
]

# Create parameters (output of inner solver)
# These depend on hparams in the computation graph
params = [
    torch.tensor([2.0, 3.0, 4.0, 5.0], requires_grad=True),
    torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
]

# Ensure params depend on hparams in the graph
params[0] = params[0] + hparams[0].sum() * 0.1
params[1] = params[1] + hparams[1].sum() * 0.1

# Define outer loss function
# Takes params and hparams, returns a scalar loss
def outer_loss(params: List[Tensor], hparams: List[Tensor]) -> Tensor:
    # Simple outer objective: sum of squared parameters plus regularization on hparams
    loss = torch.sum(params[0] ** 2) + torch.sum(params[1] ** 2)
    loss = loss + 0.01 * (torch.sum(hparams[0] ** 2) + torch.sum(hparams[1] ** 2))
    return loss

ARGS = {
    "params": params,
    "hparams": hparams,
    "outer_loss": outer_loss,
    "set_grad": True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
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
stocbio Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
junjieyang97/mrvrbo/stocBiO.py
code served (permissive licence) · get_code("e8238fd3ed908a9f")
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 Tensor, ndim 1, dtype family float, shape (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 torch
import torch.nn as nn
from torch.nn import functional as F

torch.manual_seed(0)

# Simple model that takes data and params and produces output
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x, params=None):
        # If params provided, use them; otherwise use self.parameters()
        if params is not None:
            return F.linear(x, params[0], params[1] if len(params) > 1 else None)
        return self.linear(x)

# Create model and extract parameters
model = SimpleModel()
params = nn.Parameter(torch.randn(3, 4, requires_grad=True))

# Create hparams (hyperparameters) - needs to be a tensor with requires_grad=True
hparams = nn.Parameter(torch.randn(2, requires_grad=True))

# Output function: takes data and params, returns model output
def out_f(data, params):
    # Simple linear transformation
    return torch.matmul(data, params.t())

# Regularization function: takes params, hparams, and loss
def reg_f(params, hparams, loss):
    # Add L2 regularization scaled by hparams
    reg_term = hparams[0] * torch.sum(params ** 2) + hparams[1] * torch.sum(loss)
    return reg_term

# Create args object with required attributes
class Args:
    def __init__(self):
        self.eta = 0.01
        self.hessian_q = 2

args = Args()

# Create small batch data and labels
# data_list: 3 batches of data (for Fy, Gy first call, Gy second call)
data_list = [
    torch.randn(2, 4),  # batch 1
    torch.randn(2, 4),  # batch 2
    torch.randn(2, 4),  # batch 3
]

# labels_list: 3 batches of labels (for Fy, Gy first call, Gy second call)
labels_list = [
    torch.randint(0, 3, (2,)),  # batch 1 labels
    torch.randint(0, 3, (2,)),  # batch 2 labels
    torch.randint(0, 3, (2,)),  # batch 3 labels
]

val_data_list = (data_list, labels_list)

ARGS = {
    'params': params,
    'hparams': hparams,
    'val_data_list': val_data_list,
    'args': args,
    'out_f': out_f,
    'reg_f': reg_f,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (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
mstsa Not yet run
unverified (harvested, no recorded run)
junjieyang97/mrvrbo/stocBiO.py
code served (permissive licence) · get_code("26aebb9780915816")
How it ran

no invocation recorded.

stable Not yet run
unverified (harvested, no recorded run)
junjieyang97/mrvrbo/stocBiO.py
code served (permissive licence) · get_code("149effd1caaad2cb")
How it ran

no invocation recorded.

Also present in other papers' code

Of 10 samples lifted from this paper's linked repositories, 10 carry a function identity and 0 do not. Of the 9 distinct functions with an identity, 6 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 0 the same month, 2 later) and 3 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
cat_list_to_tensor 6 other papers
4 dated earlier, 2 later · 2 only as an assembly brick
1803.06396 (2018-03)
Reviving and Improving Recurrent Back-Propagation
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
2006.14606 (2020-06)
Global Convergence and Generalization Bound of Gradient-Based Meta-Learning with Deep Neural Nets
and 3 more not named here
fixed_point 4 other papers
3 dated earlier, 1 later
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
2006.16218 (2020-06)
On the Iteration Complexity of Hypergradient Computation
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
and 1 more not named here
reverse 3 other papers
3 dated earlier
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
2006.16218 (2020-06)
On the Iteration Complexity of Hypergradient Computation
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
reverse_unroll 3 other papers
3 dated earlier
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
2006.16218 (2020-06)
On the Iteration Complexity of Hypergradient Computation
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
cg 2 other papers
2 dated earlier
2006.14606 (2020-06)
Global Convergence and Generalization Bound of Gradient-Based Meta-Learning with Deep Neural Nets
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
loss_train_avg 1 other paper
1 dated earlier
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design

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

Bilevel optimization has been widely applied in many important machine learning applications such as hyperparameter optimization and meta-learning. Recently, several momentum-based algorithms have been proposed to solve bilevel optimization problems faster. However, those momentum-based algorithms do not achieve provably better computational complexity than O( -2 ) of the SGD-based algorithm. In this paper, we propose two new algorithms for bilevel optimization, where the first algorithm adopts momentum-based recursive iterations, and the second algorithm adopts recursive gradient estimations in nested loops to decrease the variance. We show that both algorithms achieve the complexity of O( -1.5 ), which outperforms all existing algorithms by the order of magnitude. Our experiments validate our theoretical results and demonstrate the superior empirical performance of our algorithms in hyperparameter applications.

For agents

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

get_harvested_code_for_paper("2106.04692")
get_code_for_paper("2106.04692")
have("2106.04692")

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

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

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

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

Connect an agent — have() is free.