SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2004.03736 · 2020

Learning Mixed-Integer Convex Optimization Strategies for Robot Planning and Control

arXiv · PDF · Open in the Atlas

Code that ran

18 of 21 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; 0 honoured the contract we drafted, 0 violated it and 18 have no contract verdict; 0 failures of our instrument; 3 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/2004.03736.json · badge: /api/ran/2004.03736.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
bstellato/mlopt canonical (classifier label)
classifier basis: census
9 ran · 3 no recorded run
StanfordASL/CoCo canonical (classifier label)
classifier basis: census
9 ran · 0 no recorded run
FunctionStatusWhere it lives
align_z Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/utils.py
code served (permissive licence) · get_code("137827b39c64e2cd")
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 ndarray, ndim 2, dtype family float, shape (3, 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 numpy as np

ARGS = {
    'v': np.array([0.5, 0.3, 0.8])
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 2, dtype family float, shape (3, 3) — shape (3, 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
count_occurrences Ran
ran on a synthesized input
bstellato/mlopt/mlopt/sampling.py
code served (permissive licence) · get_code("a2018ad56865ac15")
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 int, ndim 0, dtype family int, 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

# The function count_occurrences takes:
# - labels: a numpy array of labels
# - i: an integer value to count occurrences of

# Create a simple numpy array of labels
labels = np.array([0, 1, 2, 1, 0, 2, 1, 0])

# Create an integer value to count
i = 1

ARGS = {
    "labels": labels,
    "i": i
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, 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
create_kkt_system Ran
ran on a synthesized input
bstellato/mlopt/mlopt/kkt.py
code served (permissive licence) · get_code("dc982b26a4eb7860")
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 cvxpy.settings as cps
import scipy.sparse as spa
import numpy as np

# Create a minimal data dictionary with required keys
n_variables = 4
n_constraints = 3

# Create a small positive definite matrix for P
P = spa.csc_matrix(np.array([
    [2.0, 0.5, 0.0, 0.0],
    [0.5, 2.0, 0.0, 0.0],
    [0.0, 0.0, 1.5, 0.0],
    [0.0, 0.0, 0.0, 1.5]
]))

# Create a constraint matrix A (n_constraints x n_variables)
A_reduced = spa.csc_matrix(np.array([
    [1.0, 1.0, 0.5, 0.2],
    [0.0, 1.0, 1.0, 0.3],
    [0.5, 0.0, 1.0, 1.0]
]))

# Create Q vector (n_variables,)
Q = np.array([1.0, 2.0, 0.5, 1.5])

# Create B vector (n_constraints,)
B_reduced = np.array([5.0, 3.0, 4.0])

# Construct data dictionary with cvxpy.settings keys
data = {
    cps.P: P,
    cps.A + '_red': A_reduced,
    cps.Q: Q,
    cps.B + '_red': B_reduced
}

ARGS = {
    'data': data
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cvxpy, numpy, scipy — 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
cylinder_grasp_from_normal Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/utils.py
code served (permissive licence) · get_code("9add8ce8a8cd2908")
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 numpy as np

# The function signature is:
# cylinder_grasp_from_normal(v, h, r)
# where:
#   v is a vector (3D array)
#   h is a scalar (height)
#   r is a scalar (radius)

# Create valid arguments
v = np.array([0.1, 0.2, 0.5])  # A 3D normal vector pointing mostly upward
h = 1.0  # height parameter
r = 0.3  # radius parameter

ARGS = {
    "v": v,
    "h": h,
    "r": r,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
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
find_obs Ran
ran on a synthesized input
StanfordASL/CoCo/free_flyer/utils.py
code served (permissive licence) · get_code("d1fe838ee72a7530")
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 list, 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 numpy as np

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

# Define parameters for find_obs function
x0 = np.array([1.0, 1.0])  # Starting position
n_obs = 2  # Number of obstacles to generate
posmin = np.array([0.0, 0.0])  # Minimum position bounds
posmax = np.array([10.0, 10.0])  # Maximum position bounds
border_size = 0.5  # Border size around obstacles
box_buffer = 0.2  # Buffer around obstacle boxes
min_box_size = 0.5  # Minimum obstacle box size
max_box_size = 2.0  # Maximum obstacle box size
max_iter = 100  # Maximum iterations for obstacle generation
ignore_intersection = True  # Whether to ignore obstacle intersections

ARGS = {
    'x0': x0,
    'n_obs': n_obs,
    'posmin': posmin,
    'posmax': posmax,
    'border_size': border_size,
    'box_buffer': box_buffer,
    'min_box_size': min_box_size,
    'max_box_size': max_box_size,
    'max_iter': max_iter,
    'ignore_intersection': ignore_intersection
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, 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
generate_first_N_primes Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/halton_sampling.py
code served (permissive licence) · get_code("5ed80f4b510304ee")
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 list, 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 torch

def generate_first_N_primes(N):
    ii, jj, flag = (0, 0, 0)
    primes = []
    for ii in range(1, N + 1, 1):
        if ii == 1 or ii == 0:
            continue
        flag = 1
        for jj in range(2, ii // 2 + 1, 1):
            if ii % jj == 0:
                flag = 0
                break
        if flag == 1:
            primes.append(ii)
    return primes

ARGS = {
    "N": 20
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 int — 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
generate_halton_samples Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/halton_sampling.py
code served (permissive licence) · get_code("c2c10a8d08b38d3a")
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 ndarray, 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 numpy as np

# Analyze the function signature and body:
# generate_halton_samples(dim, n, sf=[1])
# - dim: integer, dimensionality
# - n: integer, number of samples
# - sf: list/array of scaling factors, default [1]
# The function uses:
#   - generate_first_N_primes(1000) to get prime numbers
#   - len(sf) compared to dim
#   - sf[idx] to index into scaling factors
#   - generate_halton_sequence(n, base_val) for each dimension

# Small test values
dim = 4
n = 3
sf = np.array([1.0, 1.0, 1.0, 1.0])

ARGS = {
    'dim': dim,
    'n': n,
    'sf': sf
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 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
generate_halton_sequence Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/halton_sampling.py
code served (permissive licence) · get_code("5bd46aa88457ea8d")
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 ndarray, ndim 1, dtype family float, shape (10,) 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

ARGS = {
    "n": 10,
    "base": 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 (10,) — shape (10,) 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_n_processes Ran
ran on a synthesized input
bstellato/mlopt/mlopt/utils.py
code served (permissive licence) · get_code("fc2f60aba08f5e4c")
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 int, ndim 0, dtype family int, 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
import os
import joblib

# The function get_n_processes takes one parameter: max_n
# It uses max_n to compute: min(max_n, n_cpus)
# max_n defaults to np.inf and should be a numeric value
# We'll test with a reasonable integer value

ARGS = {
    'max_n': 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
joblib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, 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
is_free_state Ran
ran on a synthesized input
StanfordASL/CoCo/free_flyer/utils.py
code served (permissive licence) · get_code("9bfc400e168c3407")
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 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 torch
import numpy as np

torch.manual_seed(0)

# x0 is a state (position) represented as a list or array-like with at least 2 elements [x, y]
x0 = [2.5, 3.5]

# obstacles is a list of obstacle definitions, where each obstacle is [x_min, x_max, y_min, y_max]
obstacles = [
    [0.0, 1.0, 0.0, 1.0],  # obstacle 1: x in [0, 1], y in [0, 1]
    [3.0, 4.0, 3.0, 4.0],  # obstacle 2: x in [3, 4], y in [3, 4]
]

# posmin and posmax define the bounds of the valid position space
posmin = [0.0, 0.0]
posmax = [10.0, 10.0]

ARGS = {
    "x0": x0,
    "obstacles": obstacles,
    "posmin": posmin,
    "posmax": posmax,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — 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
is_pickleable Ran
ran on a synthesized input
bstellato/mlopt/mlopt/problem.py
code served (permissive licence) · get_code("7bc48fcb12a1967f")
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 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 pickle
import torch
import torch.nn as nn

torch.manual_seed(0)

# Test with various pickleable and non-pickleable objects
pickleable_obj = {"key": "value", "number": 42, "list": [1, 2, 3]}
tensor_obj = torch.randn(2, 4)
list_obj = [1, 2, 3, "test"]
simple_class_obj = 42

# Create a simple nn.Module that is pickleable
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

model_obj = SimpleModel()

# Test with various objects
ARGS = {
    "obj": pickleable_obj
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — 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
n_features Ran
ran on a synthesized input
bstellato/mlopt/mlopt/utils.py
code served (permissive licence) · get_code("f0786d99f7c22878")
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 int, ndim 0, dtype family int, 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 pandas as pd
import numpy as np

# Create a dataframe where cells contain tuples
# The function sums the sizes of flattened tuples in the first row
df = pd.DataFrame({
    'col1': [(1, 2, 3), (4, 5, 6)],
    'col2': [(7, 8), (9, 10)],
    'col3': [np.array([11, 12, 13, 14]), np.array([15, 16, 17, 18])]
})

ARGS = {
    'df': df
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, 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
obs_intersect Ran
ran on a synthesized input
StanfordASL/CoCo/free_flyer/utils.py
code served (permissive licence) · get_code("37170b6175afdf5d")
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 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 torch
import numpy as np

torch.manual_seed(0)

# The function obs_intersect takes two observations and checks if they intersect
# based on bounding box logic. Each obs appears to be a sequence/array with at least 4 elements
# accessed via indices 0, 1, 2, 3 (likely [x_min, x_max, y_min, y_max] or similar 2D bbox format)

# Create two observations as lists/tuples representing 2D bounding boxes
# Format appears to be: [dim0_min, dim0_max, dim1_min, dim1_max]
obs_1 = [1.0, 5.0, 2.0, 6.0]  # x: 1-5, y: 2-6
obs_2 = [3.0, 7.0, 4.0, 8.0]  # x: 3-7, y: 4-8 (intersects with obs_1)

ARGS = {
    "obs_1": obs_1,
    "obs_2": obs_2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — 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
pandas2array Ran
ran on a synthesized input
bstellato/mlopt/mlopt/utils.py
code served (permissive licence) · get_code("fc846b70a5af775a")
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 ndarray, ndim 2, dtype family int, shape (2, 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
import pandas as pd

# Test case 1: numpy array (should be returned as-is)
X_numpy = np.array([[1, 2, 3], [4, 5, 6]])

# Test case 2: DataFrame with simple scalar values
X_df_simple = pd.DataFrame({
    'col1': [1, 2, 3],
    'col2': [4, 5, 6],
    'col3': [7, 8, 9]
})

# Test case 3: DataFrame with tuple elements (the main use case)
X_df_tuples = pd.DataFrame({
    'col1': [(1, 2), (3, 4)],
    'col2': [(5, 6), (7, 8)],
    'col3': [9, 10]
})

# Test case 4: Series (should be converted to DataFrame and transposed)
X_series = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])

# Use the numpy array version for the main test
ARGS = {
    'X': X_df_tuples
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family int, shape (2, 5) — shape (2, 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
populate_and_solve Ran
ran on a synthesized input
bstellato/mlopt/mlopt/problem.py
code served (permissive licence) · get_code("f967f5292af2a4df")
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 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

torch.manual_seed(0)

class StandInProblem:
    """Minimal problem class with populate and solve methods."""
    
    def __init__(self):
        self.theta_value = None
    
    def populate(self, theta):
        """Store theta in the problem."""
        self.theta_value = theta
    
    def solve(self):
        """Solve and return results."""
        if self.theta_value is None:
            raise ValueError("Problem not populated")
        # Return a simple result dict
        return {
            "solution": self.theta_value * 2,
            "status": "solved"
        }

# Create problem instance
problem = StandInProblem()

# Create theta as a simple tensor or array
theta = torch.tensor([1.0, 2.0, 3.0, 4.0])

ARGS = {
    "problem": problem,
    "theta": theta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
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
skew Ran
ran on a synthesized input
StanfordASL/CoCo/manipulation/utils.py
code served (permissive licence) · get_code("e82c6a4c608cad2b")
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 ndarray, ndim 2, dtype family float, shape (3, 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 numpy as np

def skew(v):
    out = np.array([[0.0, -v[2], v[1]], [v[2], 0.0, -v[0]], [-v[1], v[0], 0.0]])
    return out

# The function takes a vector v and constructs a skew-symmetric matrix
# v must be indexable with indices 0, 1, 2 (a 3-element vector)
v = np.array([1.0, 2.0, 3.0])

ARGS = {
    'v': v
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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 2, dtype family float, shape (3, 3) — shape (3, 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
uniform_sphere_sample Ran
ran on a synthesized input
bstellato/mlopt/mlopt/sampling.py
code served (permissive licence) · get_code("e8010cc38c163110")
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 ndarray, ndim 2, dtype family float, shape (3, 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 numpy as np
from scipy.special import gammainc

np.random.seed(42)

ARGS = {
    "center": np.array([0.0, 0.0, 0.0]),
    "radius": 1.5,
    "n": 3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (3, 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
unique_strategies Ran
ran on a synthesized input
bstellato/mlopt/mlopt/strategy.py
code served (permissive licence) · get_code("68ad7954b7f37a93")
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 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

class Strategy:
    """Simple Strategy class for testing."""
    def __init__(self, name):
        self.name = name
    
    def __hash__(self):
        return hash(self.name)
    
    def __eq__(self, other):
        if not isinstance(other, Strategy):
            return False
        return self.name == other.name
    
    def __repr__(self):
        return f"Strategy({self.name})"

torch.manual_seed(0)

strategy1 = Strategy("strategy_a")
strategy2 = Strategy("strategy_b")
strategy3 = Strategy("strategy_a")
strategy4 = Strategy("strategy_c")

strategies = [strategy1, strategy2, strategy3, strategy4]

ARGS = {
    "strategies": strategies
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
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
create_kkt_matrix Not yet run
unverified (harvested, no recorded run)
bstellato/mlopt/mlopt/kkt.py
code served (permissive licence) · get_code("7f161af54975aa0a")
How it ran

no invocation recorded.

create_kkt_rhs Not yet run
unverified (harvested, no recorded run)
bstellato/mlopt/mlopt/kkt.py
code served (permissive licence) · get_code("ebc080c85115e411")
How it ran

no invocation recorded.

sample_around_points Not yet run
unverified (harvested, no recorded run)
bstellato/mlopt/mlopt/sampling.py
code served (permissive licence) · get_code("e73f5be563a1d3cd")
How it ran

no invocation recorded.

Also present in other papers' code

Of 21 samples lifted from this paper's linked repositories, 21 carry a function identity and 0 do not. Of the 21 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 21 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-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

Mixed-integer convex programming (MICP) has seen significant algorithmic and hardware improvements with several orders of magnitude solve time speedups compared to 25 years ago. Despite these advances, MICP has been rarely applied to real-world robotic control because the solution times are still too slow for online applications. In this work, we present the CoCo (Combinatorial Offline, Convex Online) framework to solve MICPs arising in robotics at very high speed. CoCo encodes the combinatorial part of the optimal solution into a strategy. Using data collected from offline problem solutions, we train a multiclass classifier to predict the optimal strategy given problem-specific parameters such as states or obstacles. Compared to previous approaches, we use task-specific strategies and prune redundant ones to significantly reduce the number of classes the predictor has to select from, thereby greatly improving scalability. Given the predicted strategy, the control task becomes a small convex optimization problem that we can solve in milliseconds. Numerical experiments on a cart-pole system with walls, a free-flying space robot, and task-oriented grasps show that our method provides not only 1 to 2 orders of magnitude speedups compared to state-of-the-art solvers but also performance close to the globally optimal MICP solution.

For agents

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

get_harvested_code_for_paper("2004.03736")
get_code_for_paper("2004.03736")
have("2004.03736")

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

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

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

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

Connect an agent — have() is free.