| ds_arg |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/process_program.py code served (permissive licence) · get_code("b75be4391719a2b0") 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)
# Analyzing the ds_arg function:
# - logic: a dict with 'func' (str) and 'args' (list) keys
# - all: a list that gets appended to
# - pos_d: a dict mapping strings to values
# The function processes a nested logic structure, where args can be dicts or strings
# Create minimal test data
logic = {
'func': 'eq',
'args': ['arg1', 'arg2']
}
all_list = []
pos_d = {
'arg1': 'value1',
'arg2': 'value2'
}
ARGS = {
'logic': logic,
'all': all_list,
'pos_d': pos_d
}
- 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
|
| find_index |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/fill_in_template.py code served (permissive licence) · get_code("534cdb9a35bb5f05") 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 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
torch.manual_seed(0)
# Construct a simple 2D table (list of lists) with some values
table = [
[10, 20, 30],
[40, 50, 60],
[70, 80, 90]
]
# The value to search for
val = 50
ARGS = {
"val": val,
"table": table
}
- 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 tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| find_num |
Ran ran on a synthesized input |
leezythu/uctr/TAT-QA/finqa/collect_data.py code served (permissive licence) · get_code("18e12d28c390eca0") 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
torch.manual_seed(0)
# Analyze what find_num expects:
# - program: a string containing operations, parentheses, commas, numbers, and possibly comments/const
# The function processes a program string by:
# 1. Removing all operation names
# 2. Removing parentheses
# 3. Splitting by comma and collecting items that don't start with '#' or 'const'
# Create test programs with various formats
program1 = "add(5, 3), subtract(10, 2), multiply(4, 6)"
program2 = "table_sum(#1, #2), divide(100, 5), 42, const_value"
program3 = "greater(x, y), exp(z), table_max(a, b, c)"
program4 = "add(1, 2), #comment, const_x, 99, subtract(10, 5)"
# Test with a simple program
test_program = "add(#1, table_max(2, 3)), subtract(const_x, 15), multiply(x, y), 42"
ARGS = {
"program": test_program
}
- 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
|
| find_pos |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/process_program.py code served (permissive licence) · get_code("4f0aabb25ef5e927") 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 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
torch.manual_seed(0)
# Analyze the function:
# - find_pos takes 'rows' parameter
# - rows is indexed as rows[0], rows[1], etc. (list-like)
# - rows[j] is indexed by i (list-like)
# - rows[j][i] are individual elements that can be dict keys (hashable)
# - The function builds a dict mapping elements to strings
# Construct valid rows argument
rows = [
['a', 'b', 'c'], # rows[0] - header row
['x', 'y', 'z'], # rows[1] - first data row
['a', 'new_val', 'c'], # rows[2] - second data row with one new element
]
ARGS = {
'rows': rows
}
- 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 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
|
| find_pos |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/syn.py code served (permissive licence) · get_code("a8deec34bf20a0a4") 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 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
# Analyzing the function find_pos:
# - It takes a parameter 'table'
# - It iterates over keys in 'table' (so table must be iterable like a dict)
# - It accesses table[key] to get values
# - The function builds a new dict 'd' with keys like 'c0', 'val_0', etc.
# The simplest valid argument is a dictionary with some key-value pairs
table = {
'key_a': 'value_1',
'key_b': 42,
'key_c': [1, 2, 3],
'key_d': {'nested': True}
}
ARGS = {
'table': table
}
- 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
|
| fuzzy_compare_filter |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/execution/APIs.py code served (permissive licence) · get_code("9b7f0f8a8a9d658e") 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 DataFrame. 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 pandas as pd
import numpy as np
# Create a sample DataFrame with mixed content (dates and numbers)
df = pd.DataFrame({
'dates': ['January 15, 2020', 'February 3, 2021', 'March 22, 2019', 'April 10, 2020'],
'values': ['Price: 100.5', 'Cost = 250', 'Amount: 75.25', 'Total 500']
})
# Define ARGS dictionary with all required parameters
ARGS = {
't': df,
'col': 'dates',
'val': 'January 2020',
'type': 'eq'
}
- 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 DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
|
| fuzzy_match_filter |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/execution/APIs.py code served (permissive licence) · get_code("bd791c82a8efe829") 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 DataFrame. 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 pandas as pd
ARGS = {
't': pd.DataFrame({
'col_A': ['hello world', 'foo bar', 'test data'],
'col_B': ['some value', 'another entry', 'more text']
}),
'col': 'col_A',
'val': 'hello',
'negate': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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_description |
Ran ran on a synthesized input |
leezythu/uctr/TAT-QA/finqa/collect_data.py code served (permissive licence) · get_code("e625b89f3bb8669a") 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
# Construct a valid table structure
# The function searches for 'num' in table[i][j] for i,j >= 1
# table[0][0] is unused, table[i][0] are row names, table[0][j] are column names
# table[i][j] for i,j >= 1 contains the data to search
table = [
[None, "Color", "Size", "Material"], # row 0: headers (table[0][0] unused, then col names)
["Fruits", ["apple", "banana"], ["orange"], ["grape", "kiwi"]], # row 1
["Vegetables", ["carrot"], ["lettuce", "spinach"], ["broccoli"]], # row 2
["Metals", ["iron", "gold"], ["silver"], ["copper", "bronze"]], # row 3
]
# The function looks for 'num' (a string or item) in the nested lists
# Let's search for something that exists
num = "apple"
ARGS = {
"num": num,
"table": table
}
- 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_evidence |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/fill_in_template.py code served (permissive licence) · get_code("b3ccf463e4486dce") 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.
# Setup code for get_evidence function
# Construct feed_dict with 'c' prefixed keys for 'count' type
feed_dict = {
'c0': 'value1',
'c1': 'value2',
'c2': 'value3'
}
# Construct must_have list with values that exist in the table
must_have = ['apple', 'banana', 'cherry']
# Construct type parameter
type_param = 'row2text'
# Construct table_index
table_index = 0
# Construct doc string
doc = 'document_1'
# Construct table as 2D list (4 rows x 3 columns with distinct sizes)
table = [
['header1', 'header2', 'header3'],
['apple', 'red', '5'],
['banana', 'yellow', '3'],
['cherry', 'red', '7']
]
# Construct is_header as 2D boolean list (4 rows x 3 columns)
# Row 0 is header, other rows are data
is_header = [
[True, True, True],
[False, False, False],
[False, False, False],
[False, False, False]
]
# Define ARGS dict mapping all parameters
ARGS = {
'feed_dict': feed_dict,
'must_have': must_have,
'type': type_param,
'table_index': table_index,
'doc': doc,
'table': table,
'is_header': is_header
}
- 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 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
|
| get_mapping |
Ran ran on a synthesized input |
leezythu/uctr-st/TAT-QA/generate_pseudo.py code served (permissive licence) · get_code("defe43aaba4c6447") 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 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 math
# Construct table argument
# The function iterates through table[i][j] and checks if fact is in the string
# or if the numeric value matches
table = [
['10', '20.5', 'text with 30 in it'],
['$1,000', '(50%)', 'description'],
['data', '100', 'another entry']
]
# Construct para argument
# The function accesses p['text'] and p['order'] for each paragraph
para = [
{'text': 'This paragraph contains the fact 10 and some more text', 'order': 0},
{'text': 'Another paragraph with value 20.5 mentioned here', 'order': 1},
{'text': 'Final paragraph with reference to 100 in the content', 'order': 2}
]
# Construct facts argument
# The function checks if facts match table entries or paragraph text
# It handles floats, integers, and strings
facts = [10, 20.5, '100', 'text with 30 in it']
ARGS = {
'table': table,
'para': para,
'facts': facts
}
- 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 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
|
| get_para_mapping |
Ran ran on a synthesized input |
leezythu/uctr-st/TAT-QA/generate_pseudo.py code served (permissive licence) · get_code("a4ec9baf2fc7a4f5") 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 torch
def get_para_mapping(para, fact):
for p in para:
text = p['text'].lower()
rel_index = p['order']
try:
start_idx = text.index(fact.lower())
except:
continue
end_idx = start_idx + len(fact)
return (rel_index, [start_idx, end_idx])
return (None, None)
# Construct valid arguments
para = [
{
'text': 'The quick brown fox jumps over the lazy dog',
'order': 0
},
{
'text': 'Another paragraph with some text',
'order': 1
},
{
'text': 'Third paragraph containing a fact here',
'order': 2
}
]
fact = 'brown fox'
ARGS = {
'para': para,
'fact': fact
}
- 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 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
|
| get_table_mapping |
Ran ran on a synthesized input |
leezythu/uctr-st/TAT-QA/generate_pseudo.py code served (permissive licence) · get_code("ce5896bb3ae606e2") 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
# The function iterates through a 2D table (list of lists)
# and searches for a string representation of 'fact' or numeric equivalence
# It returns [i, j] indices or None
# Create a sample table with mixed content
table = [
["Name", "Value", "Status"],
["Item1", "42", "Active"],
["Item2", "($100.50)", "Inactive"],
["Item3", "95%", "Pending"]
]
# Create a fact to search for - can be a string or number
fact = 42
ARGS = {
"table": table,
"fact": fact
}
- 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
|
| locate_num |
Ran ran on a synthesized input |
leezythu/uctr/TAT-QA/finqa/collect_data.py code served (permissive licence) · get_code("a79f0ace7e53331c") 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 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
# The function locate_num searches through a 2D table structure
# looking for a number within nested containers at each position.
# It returns the (i, j) coordinates where num is found, or (None, None).
# Create a simple 2D table where each cell contains a collection
# The function checks "if num in table[i][j]", so each cell needs to be
# a container that supports the 'in' operator (list, set, tuple, etc.)
table = [
[set(), {1, 2, 3}, {4, 5, 6}],
[{7, 8}, {9, 10, 11}, {12, 13}],
[{14}, {15, 16, 17}, {18, 19, 20}]
]
num = 11
ARGS = {
"num": num,
"table": table
}
- 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 int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| normalize |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/syn.py code served (permissive licence) · get_code("c4ae14071abdbcdf") 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 random
import json
import re
class MockRow:
def __init__(self, cell_content):
self.cell_content = cell_content
# Create a row object with cell_content attribute
# The function processes items in cell_content looking for [[...]] patterns
# and replaces them with the part after the pipe
row_obj = MockRow([
"some text [[link|display text]] more text",
"normal item without pattern",
"another [[internal|external]] reference",
"no brackets here"
])
ARGS = {
"row": row_obj
}
- 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 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
|
| normalize |
Ran ran on a synthesized input |
leezythu/uctr-st/SEM-TAB-FACTS/syn.py code served (permissive licence) · get_code("cfb7267da4dc4f92") 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 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 torch
# Construct a simple 2D table with string entries containing newlines and extra spaces
table = [
["hello\nworld", "foo bar", "test\n\nmultiple"],
["line1\nline2", "a b c", "x\ny\nz"]
]
ARGS = {
"table": table
}
- 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 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
|
| obj_compare |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/execution/APIs.py code served (permissive licence) · get_code("f36c3eba21146e55") 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 math
torch_seed = __import__('torch').manual_seed(0)
ARGS = {
'num1': 3.14159,
'num2': 3.14160,
'round': False,
'type': 'eq'
}
- 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
|
| paraphrase |
Ran ran on a synthesized input |
leezythu/uctr/FEVEROUS/process_program.py code served (permissive licence) · get_code("3941e0c5c9a3493d") 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 = {
'func': 'eq'
}
- 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
|
| execute_all |
Not yet run unverified (harvested, no recorded run) |
leezythu/uctr/FEVEROUS/execution/execute.py code served (permissive licence) · get_code("bb7c3358b37dc877") How it ran |
| gen_feed |
Not yet run unverified (harvested, no recorded run) |
leezythu/uctr/FEVEROUS/syn.py code served (permissive licence) · get_code("59e65dbe081b83ae") How it ran |
| gen_feed |
Not yet run unverified (harvested, no recorded run) |
leezythu/uctr/SEM-TAB-FACTS/syn.py code served (permissive licence) · get_code("0f626cad0a001441") How it ran |