| add_hierarchical_offset_2d |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/data.py code served (permissive licence) · get_code("b0d450e5bb923406") How it ranRan 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 (8, 6) 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 2D array to use as input
f = np.random.randn(8, 6).astype(np.float32)
# Create a random number generator
rng = np.random.default_rng(seed=42)
# Define all arguments
ARGS = {
"f": f,
"K_max": 6,
"sigma": 0.5,
"rng": rng
}
- 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 (8, 6) — shape (8, 6) 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
|
| build_legacy_suffix |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/operator_accuracy.py code served (permissive licence) · get_code("346f3fb157d99d7e") How it ranRan 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 str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from collections import namedtuple
torch.manual_seed(0)
class Args:
def __init__(self, pde_type, grf_alpha, grf_tau, grf_offset_sigma=None,
fiber_core_radius_factor=None, fiber_potential_depth=None,
grin_strength=None, evolution_time_T=None, solver_num_steps=None,
viscosity_nu=None):
self.pde_type = pde_type
self.grf_alpha = grf_alpha
self.grf_tau = grf_tau
self.grf_offset_sigma = grf_offset_sigma
self.fiber_core_radius_factor = fiber_core_radius_factor
self.fiber_potential_depth = fiber_potential_depth
self.grin_strength = grin_strength
self.evolution_time_T = evolution_time_T
self.solver_num_steps = solver_num_steps
self.viscosity_nu = viscosity_nu
ARGS = {
'args': Args(
pde_type='poisson',
grf_alpha=1.5,
grf_tau=0.8,
grf_offset_sigma=0.3,
fiber_core_radius_factor=2.5,
fiber_potential_depth=3.2,
grin_strength=1.5e-3,
evolution_time_T=1.0e-2,
solver_num_steps=100,
viscosity_nu=2.5e-4
),
'grf_alpha': None
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| build_suffix |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/collection_sweep.py code served (permissive licence) · get_code("8baf73eb04f01385") How it ranRan 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 str. 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
class ConfigA:
"""Stand-in config class with all required attributes for build_suffix"""
def __init__(self):
self.grf_tau = 2.5
self.grf_offset_sigma = 1.3
self.fiber_core_radius_factor = 0.8
self.fiber_potential_depth = 5.2
self.evolution_time_T = 0.001
self.solver_num_steps = 100
self.grin_strength = 1.5e-3
self.viscosity_nu = 2.1e-4
ARGS = {
'pde_type': 'poisson',
'a': ConfigA(),
'grf_alpha': 1.5
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| build_suffix |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/operator_accuracy.py code served (permissive licence) · get_code("ad37cae170cd3854") How it ranRan 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 str. 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
class Args:
def __init__(self, pde_type, grf_alpha, grf_tau, grf_offset_sigma=None,
fiber_core_radius_factor=None, fiber_potential_depth=None,
evolution_time_T=None, solver_num_steps=None, grin_strength=None,
viscosity_nu=None):
self.pde_type = pde_type
self.grf_alpha = grf_alpha
self.grf_tau = grf_tau
self.grf_offset_sigma = grf_offset_sigma
self.fiber_core_radius_factor = fiber_core_radius_factor
self.fiber_potential_depth = fiber_potential_depth
self.evolution_time_T = evolution_time_T
self.solver_num_steps = solver_num_steps
self.grin_strength = grin_strength
self.viscosity_nu = viscosity_nu
ARGS = {
'args': Args(
pde_type='poisson',
grf_alpha=1.5,
grf_tau=0.8,
grf_offset_sigma=0.3,
fiber_core_radius_factor=2.0,
fiber_potential_depth=5.0,
evolution_time_T=1e-2,
solver_num_steps=100,
grin_strength=1.5e-3,
viscosity_nu=2.5e-4
),
'grf_alpha': None
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| calculate_I_AB_components_torch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/robust_opt.py code served (permissive licence) · get_code("32542ac2d757d6ae") How it ranRan 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 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 numpy as np
torch.manual_seed(0)
# Create small tensors for testing
M_val = 4
# phi_params_torch: shape (M_val - 1,) since the function concatenates [0.0] with it
phi_params_torch = torch.tensor([0.1, 0.2, 0.3], dtype=torch.float64)
# x_s_torch: shape (M_val,) - represents signal values
x_s_torch = torch.tensor([1.0, 0.5, 0.3, 0.2], dtype=torch.float64)
# q_priors_torch: shape (M_val,) - prior probabilities that sum to 1
q_priors_torch = torch.tensor([0.25, 0.25, 0.25, 0.25], dtype=torch.float64)
# eps: small epsilon for numerical stability
eps = 1e-12
ARGS = {
"phi_params_torch": phi_params_torch,
"M_val": M_val,
"x_s_torch": x_s_torch,
"q_priors_torch": q_priors_torch,
"eps": eps,
}
- 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 tuple, ndim 1, 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
|
| calculate_conditional_probs_p_j_given_k_torch |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/robust_opt.py code served (permissive licence) · get_code("f03101ca398d9223") How it ranRan 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 Tensor, 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 torch
import numpy as np
torch.manual_seed(0)
# M_val is the dimension parameter used throughout
M_val = 4
# phi_full_torch: used as torch tensor, needs .to(device), and passed to torch.cos and torch.sin
# Shape should be (M_val,) based on the loop structure where it's element-wise multiplied with x_s_torch
phi_full_torch = torch.randn(M_val, dtype=torch.float64)
# x_s_torch: used as torch tensor with .device attribute
# Multiplied element-wise with cos/sin of phi_full_torch
# Shape should match phi_full_torch: (M_val,)
x_s_torch = torch.randn(M_val, dtype=torch.float64)
ARGS = {
"phi_full_torch": phi_full_torch,
"x_s_torch": x_s_torch,
"M_val": M_val,
}
- 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 Tensor, 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
|
| channels_to_spectrum_complex_torch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/model.py code served (permissive licence) · get_code("5604e74122809770") How it ranRan 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 Tensor, 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 torch
torch.manual_seed(0)
# The function expects a tensor with shape (2, *, *) where the first dimension
# contains real and imaginary parts. Let's create a small 3D tensor.
channels_mat_real_imag = torch.randn(2, 4, 3)
ARGS = {
"channels_mat_real_imag": channels_mat_real_imag
}
- 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 Tensor, 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
|
| channels_to_spectrum_complex_torch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/collection.py code served (permissive licence) · get_code("821053dc67710bba") How it ranRan 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 Tensor, 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 torch
torch.manual_seed(0)
# The function expects a tensor of shape [2, K, K] where:
# - First dimension (size 2) holds real and imaginary parts
# - Second and third dimensions (both size K) form a square matrix
# K can be any positive integer; using K=4 for a small tensor
K = 4
channels_mat_real_imag = torch.randn(2, K, K)
ARGS = {
'channels_mat_real_imag': channels_mat_real_imag
}
- 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 Tensor, 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
|
| expected_base |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/collection_sweep.py code served (permissive licence) · get_code("3d789b6d350a6382") How it ranRan 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 str. 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 os
ARGS = {
'results_out': '/tmp/results',
'pde_type': 1,
'Nin': 3,
'Nout': 5,
'K': 8,
'rpx': 2.5,
'alpha_for_radius': 0.75,
'suffix': 'test_run'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| first_existing |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/appendix_collection_viz.py code served (permissive licence) · get_code("f1767f684708bcc8") How it ranRan 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 str. 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 os
import tempfile
import shutil
# Create a temporary directory with a test file
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test.txt")
with open(test_file, "w") as f:
f.write("test")
# Define arguments for first_existing
ARGS = {
"candidates": [
"/nonexistent/path/one",
"/nonexistent/path/two",
test_file,
"/nonexistent/path/three"
],
"description": "test configuration file"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| generate_latex_table |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/robust_opt_sweep.py code served (permissive licence) · get_code("2c8d997e3ea51631") How it ranRan 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 str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from types import SimpleNamespace
torch.manual_seed(0)
# Build results_dict with the expected structure
results_dict = {
(0.5, 10, 32): {
'avg_pgm_IAB': 0.7234,
'avg_nominal_IAB': 0.6891,
'avg_robust_IAB': 0.7105,
'p_value_rob_gt_nom': 0.0234,
'p_value_rob_gt_pgm': 0.3421,
},
(0.3, 5, 16): {
'avg_pgm_IAB': 0.6543,
'avg_nominal_IAB': 0.7234,
'avg_robust_IAB': 0.6890,
'p_value_rob_gt_nom': 0.5678,
'p_value_rob_gt_pgm': 0.1234,
},
(0.7, 15, 64): {
'avg_pgm_IAB': 0.8123,
'avg_nominal_IAB': 0.7654,
'avg_robust_IAB': 0.8456,
'p_value_rob_gt_nom': 0.0123,
'p_value_rob_gt_pgm': 0.0456,
},
}
# Build args object with required attributes
args = SimpleNamespace(
pde_type='burgers_equation'
)
ARGS = {
'results_dict': results_dict,
'args': args,
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| get_mode_indices_and_weights |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/calibration.py code served (permissive licence) · get_code("ba928d4883913b13") How it ranRan 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
ARGS = {
"K_grid_size": 5,
"d_dimensions": 2,
"s_coeff": 2.5,
"nu_coeff": 1.0,
}
- 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
|
| load_and_prepare_dataloaders |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/model.py code served (permissive licence) · get_code("0f574e35260259c4") How it ranRan 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 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 numpy as np
import tempfile
import os
torch.manual_seed(0)
# Create a temporary directory for the dataset file
temp_dir = tempfile.mkdtemp()
dataset_path = os.path.join(temp_dir, 'test_dataset.npz')
# Create synthetic dataset with complex spectra
# Input: full spectra at resolution 4x4
# Target: truncated spectra at resolution 3x3
num_samples = 10
input_res = 4
target_res = 3
gamma_b_train = np.random.randn(num_samples, input_res, input_res) + 1j * np.random.randn(num_samples, input_res, input_res)
gamma_a_snn_target_train = np.random.randn(num_samples, target_res, target_res) + 1j * np.random.randn(num_samples, target_res, target_res)
# Save to npz file
np.savez(dataset_path, gamma_b_train=gamma_b_train, gamma_a_snn_target_train=gamma_a_snn_target_train)
ARGS = {
'dataset_path': dataset_path,
'snn_input_res_expected': input_res,
'snn_target_res_expected': target_res,
'batch_size': 2,
'val_split': 0.2,
'random_seed': 42,
}
- 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 tuple, ndim 1, 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
|
| load_radius |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/appendix_collection_viz.py code served (permissive licence) · get_code("668c3e16b59ed2f6") How it ranRan 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 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 os
import numpy as np
import tempfile
import shutil
# Create a temporary directory structure for calibration results
temp_dir = tempfile.mkdtemp()
calib_results_dir = os.path.join(temp_dir, 'calib_results')
os.makedirs(calib_results_dir, exist_ok=True)
# Create calibration data file
pde_type = 1
n_grid_sim_input_ds = 32
snn_output_res = 16
s_theorem = 0.5
nu_theorem = 0.1
suffix = 'test'
calib_filename = f'coverage_data_PDE{pde_type}_thm_s{s_theorem}_nu{nu_theorem}_d2_Nin{n_grid_sim_input_ds}_SNNout{snn_output_res}_NfullThm{n_grid_sim_input_ds}_{suffix}.npz'
calib_path = os.path.join(calib_results_dir, calib_filename)
# Create synthetic calibration data
nominal_coverages = np.array([0.85, 0.90, 0.92, 0.95, 0.97])
quantiles_q_hat_nu = np.array([0.5, 1.0, 1.5, 2.0, 2.5])
np.savez(calib_path, nominal_coverages=nominal_coverages, quantiles_q_hat_nu=quantiles_q_hat_nu)
# Create a minimal args object
class Args:
def __init__(self):
self.pde_type = pde_type
self.n_grid_sim_input_ds = n_grid_sim_input_ds
self.snn_output_res = snn_output_res
self.s_theorem = s_theorem
self.nu_theorem = nu_theorem
self.calib_results_dir = calib_results_dir
self.alpha_for_radius = 0.1
self.collection_radius_scale = 1.5
args_obj = Args()
ARGS = {
'args': args_obj,
'suffix': suffix
}
- 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, ndim 1, 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
|
| pad_to_full_centered |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/collection.py code served (permissive licence) · get_code("aef3d77c1537f553") How it ranRan 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 (12, 12) 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 centered block (4x4)
block_centered = np.array([
[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0],
[9.0, 10.0, 11.0, 12.0],
[13.0, 14.0, 15.0, 16.0]
], dtype=np.float32)
# Full size should be larger (12x12)
K_full = 12
ARGS = {
"block_centered": block_centered,
"K_full": K_full
}
- 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 (12, 12) — shape (12, 12) 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
|
| parse_float_list |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/operator_accuracy_sweep.py code served (permissive licence) · get_code("f860fb1d6549a8a1") How it ranRan 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
import numpy as np
# Analyze the function: parse_float_list takes one parameter 'raw'
# which can be a list, tuple, or string containing numeric values
# The function converts it to a list of floats
ARGS = {
'raw': [1.5, 2.3, 3.7, 4.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 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
|
| parse_int_list |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/operator_accuracy_sweep.py code served (permissive licence) · get_code("8dc6aca9ce6ae15c") How it ranRan 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
import numpy as np
# parse_int_list takes a single parameter 'raw'
# It handles list/tuple by joining them as strings
# It then processes strings by replacing commas with spaces and splitting
# Finally converts to integers, filtering out empty strings
# Test with a list input
raw_list = [1, 2, 3, 4, 5]
ARGS = {
'raw': raw_list
}
- 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 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
|
| poisson_suffix |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/appendix_collection_viz.py code served (permissive licence) · get_code("fbe8a50d4093bab9") How it ranRan 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 str. 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)
ARGS = {
'grf_alpha': 0.5,
'grf_tau': 1.2,
'grf_offset_sigma': 0.3,
}
- 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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| run_script |
Ran ran, violated the contract we drafted |
yashpatel5400/fpo/calibration_sweep.py code served (permissive licence) · get_code("56cfef58cb04093a") How it ranRan 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 os
import sys
import tempfile
# Create a temporary Python script to run
script_content = '''
import sys
print("Script executed with args:", sys.argv[1:])
sys.exit(0)
'''
# Create a temporary file for the script
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write(script_content)
script_path = f.name
try:
# Define arguments for run_script
ARGS = {
'script_name': script_path,
'args_list': ['arg1', 'arg2', 42, 3.14],
'log_prefix': '[TEST] '
}
finally:
# Clean up the temporary script after defining ARGS
# Note: We keep the file since the function will execute it
pass
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- 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
|
| run_script |
Ran ran, violated the contract we drafted |
yashpatel5400/fpo/collection_sweep.py code served (permissive licence) · get_code("b48067ba3bbdeb9d") How it ranRan 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 os
import sys
import tempfile
# Create a minimal dummy script to run
dummy_script_content = """
import sys
print(f"Script executed with args: {sys.argv[1:]}")
sys.exit(0)
"""
# Write the dummy script to a temporary file
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write(dummy_script_content)
dummy_script_path = f.name
try:
# Define arguments for run_script
ARGS = {
'script_name': dummy_script_path,
'args_list': ['arg1', 'arg2', 42, 3.14],
'log_prefix': '[TEST] ',
'env_extra': {
'CUDA_VISIBLE_DEVICES': '0',
'MY_VAR': 'my_value'
}
}
finally:
# Clean up the temporary script file after defining ARGS
pass
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- 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
|
| run_script |
Ran ran, violated the contract we drafted |
yashpatel5400/fpo/robust_opt_sweep.py code served (permissive licence) · get_code("2996eec91458a373") How it ranRan 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 os
import sys
import tempfile
# Create a temporary directory for our test script
temp_dir = tempfile.mkdtemp()
test_script = os.path.join(temp_dir, 'test_script.py')
# Write a minimal test script that accepts arguments
with open(test_script, 'w') as f:
f.write("""
import sys
print(f"Script executed with {len(sys.argv) - 1} arguments")
for i, arg in enumerate(sys.argv[1:]):
print(f"Arg {i}: {arg}")
sys.exit(0)
""")
# Define arguments for run_script
ARGS = {
'script_name': test_script,
'args_list': ['arg1', 42, 3.14, 'another_arg'],
'log_prefix': '[TEST] '
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- 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
|
| solve_poisson_2d_rfft |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/data.py code served (permissive licence) · get_code("70df22f5e0184adf") How it ranRan 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, 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 numpy as np
# Create a small complex array in rfft format
# For a 2D real FFT, the shape is (N1, M_rfft) where M_rfft = N2//2 + 1
# Let's use N1=4, N2=6, so M_rfft=4
N1 = 4
M_rfft = 4
# Create a random complex array representing rfft output
np.random.seed(0)
f_hat_r = np.random.randn(N1, M_rfft).astype(np.complex128) + 1j * np.random.randn(N1, M_rfft).astype(np.complex128)
# Make sure the zero frequency component has some value to test enforce_zero_mean
f_hat_r[0, 0] = 5.0 + 3.0j
ARGS = {
"f_hat_r": f_hat_r,
"enforce_zero_mean": True
}
- 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, 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
|
| spectrum_complex_to_channels_torch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/model.py code served (permissive licence) · get_code("c314096fa242334f") How it ranRan 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 Tensor, ndim 3, dtype family float, shape (2, 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 torch
import numpy as np
torch.manual_seed(0)
# Create a small complex spectrum matrix [K, K]
K = 4
spectrum_complex = torch.randn(K, K, dtype=torch.complex64)
ARGS = {
"spectrum_mat_complex": spectrum_complex
}
- 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 Tensor, ndim 3, dtype family float, shape (2, 4, 4) — shape (2, 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
|
| spectrum_complex_to_channels_torch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/collection.py code served (permissive licence) · get_code("89729296470c6f30") How it ranRan 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 Tensor, ndim 3, dtype family float, shape (2, 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 torch
import numpy as np
torch.manual_seed(0)
# Case 1: Complex tensor input
complex_spectrum = torch.randn(4, 4, dtype=torch.complex64)
ARGS = {
"spectrum_mat_complex": complex_spectrum
}
- 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 Tensor, ndim 3, dtype family float, shape (2, 4, 4) — shape (2, 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
|
| split_step_solver_2d |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
yashpatel5400/fpo/data.py code served (permissive licence) · get_code("cce9a1789dc85313") How it ranRan 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, 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 numpy as np
# Set random seeds for reproducibility
np.random.seed(0)
# Define parameters
N = 4 # Grid size (4x4)
dx = 0.5 # Grid spacing
T = 1.0 # Total time
num_steps = 5 # Number of time steps
hbar_val = 1.0545718e-34 # Reduced Planck constant
m_val = 9.10938e-31 # Electron mass
# Create initial wavefunction psi0 as a 2D complex array
psi0 = np.exp(-((np.arange(N) - N//2)**2)[:, None] - ((np.arange(N) - N//2)**2)[None, :]) + 0j
# Create potential grid V_grid as a 2D array
V_grid = np.zeros((N, N), dtype=np.float64)
V_grid[N//2, N//2] = 0.1 # Add a small potential at center
# Construct the ARGS dictionary
ARGS = {
'V_grid': V_grid,
'psi0': psi0,
'N': N,
'dx': dx,
'T': T,
'num_steps': num_steps,
'hbar_val': hbar_val,
'm_val': m_val,
}
- 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, 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
|
| suffix_candidates |
Ran ran; our contract draft was wrong, not the code |
yashpatel5400/fpo/operator_accuracy.py code served (permissive licence) · get_code("4e812720bbb00ede") How it ranRan 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 Args:
def __init__(self, pde_type, grf_alpha=0.5, grf_tau=0.1, grf_offset_sigma=0.05,
fiber_core_radius_factor=0.3, fiber_potential_depth=1.5,
evolution_time_T=0.01, solver_num_steps=100,
grin_strength=1e-2, viscosity_nu=1e-3):
self.pde_type = pde_type
self.grf_alpha = grf_alpha
self.grf_tau = grf_tau
self.grf_offset_sigma = grf_offset_sigma
self.fiber_core_radius_factor = fiber_core_radius_factor
self.fiber_potential_depth = fiber_potential_depth
self.evolution_time_T = evolution_time_T
self.solver_num_steps = solver_num_steps
self.grin_strength = grin_strength
self.viscosity_nu = viscosity_nu
ARGS = {
'args': Args(pde_type='poisson'),
'grf_alpha': None
}
- 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
|
| run_single_calibration_pipeline |
Not yet run unverified (harvested, no recorded run) |
yashpatel5400/fpo/calibration_sweep.py code served (permissive licence) · get_code("6f460ddccfb3254c") How it ran |
| run_single_robust_opt |
Not yet run unverified (harvested, no recorded run) |
yashpatel5400/fpo/robust_opt_sweep.py code served (permissive licence) · get_code("b4feacd478620451") How it ran |