| build_adj |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/metric.py code served (permissive licence) · get_code("d5fc6ffebec7d8b3") 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
from typing import Dict, Set, Tuple, FrozenSet
# Construct valid arguments for build_adj function
# sub_to_essay: maps sub-argument IDs to their essay IDs
sub_to_essay = {
"sub_arg_1": "essay_A",
"sub_arg_2": "essay_A",
"sub_arg_3": "essay_B",
"sub_arg_4": "essay_B",
"sub_arg_5": "essay_C",
}
# pair_rel: maps pairs of sub-arguments to their relation type
pair_rel = {
("sub_arg_1", "sub_arg_3"): "entailment",
("sub_arg_1", "sub_arg_4"): "neutral",
("sub_arg_2", "sub_arg_3"): "entailment",
("sub_arg_3", "sub_arg_5"): "contradiction",
("sub_arg_1", "sub_arg_2"): "entailment", # Same essay, should be skipped
("sub_arg_2", "sub_arg_5"): "neutral",
}
# relation_set: frozenset of relations we care about
relation_set = frozenset({"entailment", "contradiction"})
ARGS = {
"sub_to_essay": sub_to_essay,
"pair_rel": pair_rel,
"relation_set": relation_set,
}
- 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
|
| detect_layout |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/data.py code served (permissive licence) · get_code("949f421fdd434463") 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
from pathlib import Path
import tempfile
import shutil
# Create a temporary directory structure for testing
temp_dir = tempfile.mkdtemp()
# Test case 1: LAYOUT_AGGREGATE - create nyt directory
nyt_dir = Path(temp_dir) / 'nyt'
nyt_dir.mkdir(exist_ok=True)
# Alternatively, we could test other layouts by creating different structures
# But for simplicity, we'll use the aggregate layout
data_root_arg = temp_dir
ARGS = {
'data_root': data_root_arg
}
- 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
|
| essay_unique |
Ran ran, honoured the contract we drafted |
mungg/argument_collapse/src/argument_collapse/metric.py code served (permissive licence) · get_code("1a3e4ee14111fb31") 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 float, 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)
# Construct arguments for essay_unique function
essay_sub_ids = ["sub_1", "sub_2", "sub_3"]
other_sub_ids = ["sub_4", "sub_5", "sub_2"]
pair_rel = {
("sub_1", "sub_4"): "similar",
("sub_2", "sub_5"): "related",
("sub_3", "sub_2"): "different",
("sub_1", "sub_2"): "similar",
}
relation_set = frozenset(["similar", "related"])
ARGS = {
"essay_sub_ids": essay_sub_ids,
"other_sub_ids": other_sub_ids,
"pair_rel": pair_rel,
"relation_set": relation_set,
}
- 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 float, 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
|
| extract_json |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/pair_comparison_main_arg.py code served (permissive licence) · get_code("b933cab935ecc2aa") 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 json
import re
from typing import Any, Iterable
# Test cases for extract_json function
# The function takes a single parameter: text (str)
ARGS = {
"text": '{"key": "value", "number": 42}'
}
- 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
|
| extract_json |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/stance.py code served (permissive licence) · get_code("ec41fe411ec4206b") 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 json
# The function extract_json takes a single parameter: text (str)
# It processes the text to extract and parse JSON from it.
# No models, tensors, or complex objects are needed.
ARGS = {
"text": '```json\n{"key": "value", "number": 42}\n```'
}
- 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
|
| extract_json |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/structure.py code served (permissive licence) · get_code("ba2ef2aa84eacd6c") 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 json
import re
from typing import Any
torch_imported = False
try:
import torch
torch_imported = True
except ImportError:
pass
# Analyze the function: extract_json takes one parameter: text (str)
# The function processes a string to extract JSON from it
# It handles markdown code blocks, finds opening braces, tracks depth and strings
# Create various test cases for the text parameter
ARGS = {
"text": '{"key": "value", "nested": {"inner": 123}}'
}
- 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
|
| jsonable |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/inference/types.py code served (permissive licence) · get_code("cba80378bea200a8") 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
from pathlib import Path
from collections.abc import Mapping
torch.manual_seed(0)
# Create a simple class with model_dump method
class PydanticLike:
def model_dump(self):
return {"field1": "value1", "field2": 42}
# Create a simple class with to_dict method
class DictConvertible:
def to_dict(self):
return {"key1": "val1", "key2": 3.14}
# Create a complex nested structure to test the recursive behavior
complex_value = {
"none_field": None,
"str_field": "hello",
"int_field": 42,
"float_field": 3.14,
"bool_field": True,
"path_field": Path("/home/user/data"),
"list_field": [1, "two", 3.0, True, None],
"tuple_field": (1, 2, 3),
"set_field": {1, 2, 3},
"nested_dict": {
"inner": "value",
"inner_path": Path("/tmp/file.txt"),
"inner_list": [1, 2, 3]
},
"pydantic_obj": PydanticLike(),
"dict_obj": DictConvertible(),
"custom_obj": "will be converted to str"
}
ARGS = {
"value": complex_value
}
- 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
|
| normalize |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/pair_comparison_main_arg.py code served (permissive licence) · get_code("ab25f2520bea63b4") 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
torch.manual_seed(0)
# Analyze the function:
# - normalize() takes one parameter: payload (dict[str, Any])
# - It accesses payload.get('relation', ''), payload.get('rationale', ''),
# payload.get('reason', ''), payload.get('explanation', '')
# - It converts these to strings, strips whitespace, and lowercases 'relation'
# - It checks if relation is in VALID_RELATIONS
# - It returns a dict with 'relation' and 'rationale' keys
ARGS = {
'payload': {
'relation': 'equivalent',
'rationale': 'These two items are semantically the same.',
'reason': 'backup reason',
'explanation': 'backup explanation'
}
}
- 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
|
| normalize_annotation |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/structure.py code served (permissive licence) · get_code("ab1d6a9928b9ae6f") 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.
ARGS = {
'payload': {
'annotations': [
{'paragraph_index': 0, 'labels': ['label1', 'label2'], 'rationale': 'This is a rationale'},
{'paragraph_index': 1, 'labels': 'single_label', 'rationale': 'Another rationale'},
{'paragraph_index': 2, 'labels': ['label3'], 'rationale': ''}
]
},
'layer': 'argument',
'n_paragraphs': 3
}
- 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_venue |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/data.py code served (permissive licence) · get_code("91b783517dd37d3d") 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
ARGS = {
'venue': 'nyt'
}
- 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
|
| parse_frontmatter_and_body |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/data.py code served (permissive licence) · get_code("4b3d96b8a4765eb1") 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.
from pathlib import Path
import tempfile
import os
# Create a temporary directory and file with frontmatter
temp_dir = tempfile.mkdtemp()
test_file_path = Path(temp_dir) / "test.md"
# Write a markdown file with YAML frontmatter
markdown_content = """---
title: Test Document
author: John Doe
date: 2024-01-15
---
This is the body of the markdown file.
It can have multiple lines and paragraphs.
"""
test_file_path.write_text(markdown_content)
ARGS = {
"path": test_file_path
}
- 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 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
|
| split_paragraphs |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/structure.py code served (permissive licence) · get_code("57f9aa481a38511d") 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 re
def split_paragraphs(body: str) -> list[str]:
return [p.strip() for p in re.split('\\n\\s*\\n+', body.strip()) if p.strip()]
# Construct valid arguments
body = """This is the first paragraph.
It has multiple lines.
This is the second paragraph.
Also multiple lines here.
And a third paragraph
with some content."""
ARGS = {
"body": body
}
- 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
|
| user_prompt |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/pair_comparison_main_arg.py code served (permissive licence) · get_code("cf84555b316c3ce4") 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 = {
'question': 'Should artificial intelligence be regulated by governments?',
'main_i': 'AI regulation is necessary to prevent misuse and ensure safety standards across industries.',
'main_j': 'Heavy regulation stifles innovation and competitive advantage in the AI sector.',
'context_label': 'Debate question'
}
- 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
|
| user_prompt |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/pair_comparison_sub_arg.py code served (permissive licence) · get_code("2b92e56e678bfc1e") 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 = {
'question': 'Should artificial intelligence be regulated by governments?',
'main_i': 'AI regulation is necessary to protect public safety and prevent misuse.',
'sub_i': 'Unregulated AI systems could be used for harmful purposes without oversight.',
'main_j': 'AI should develop freely without government interference to maximize innovation.',
'sub_j': 'Excessive regulation stifles technological progress and economic growth.',
'context_label': 'Debate question'
}
- 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
|
| user_prompt |
Ran ran; our contract draft was wrong, not the code |
mungg/argument_collapse/src/argument_collapse/annotate/toulmin.py code served (permissive licence) · get_code("c5164adfd99fcd74") 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
torch.manual_seed(0)
ARGS = {
'context': 'Is artificial intelligence beneficial to society?',
'body': 'Artificial intelligence has transformative potential across multiple domains including healthcare, education, and scientific research. However, careful regulation is needed to ensure ethical deployment.',
'context_label': 'Debate question'
}
- 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
|
| within_unique |
Ran ran, honoured the contract we drafted |
mungg/argument_collapse/src/argument_collapse/metric.py code served (permissive licence) · get_code("8ce24061cc5dd623") 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 float, 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
from math import comb
# Set seed for reproducibility
torch.manual_seed(0)
# Construct arguments for within_unique function
# The function needs:
# 1. sub_to_essay: dict mapping sub-argument IDs to essay IDs
# 2. pair_rel: dict mapping (sub_arg1, sub_arg2) tuples to relation strings
# 3. m: int for sample size
# 4. relation_set: frozenset or set of relation strings to consider
# Build a small example with 2 essays and 4 sub-arguments
sub_to_essay = {
"sub_1": "essay_A",
"sub_2": "essay_A",
"sub_3": "essay_B",
"sub_4": "essay_B",
}
# Build pair_rel with relations between sub-arguments
# Key format: (sub_arg_id_1, sub_arg_id_2)
# Only cross-essay pairs will be considered (same essay pairs are filtered)
pair_rel = {
("sub_1", "sub_3"): "related", # essay_A to essay_B
("sub_1", "sub_4"): "unrelated", # essay_A to essay_B
("sub_2", "sub_3"): "related", # essay_A to essay_B
("sub_2", "sub_4"): "unrelated", # essay_A to essay_B
("sub_1", "sub_2"): "related", # same essay (will be filtered)
("sub_3", "sub_4"): "related", # same essay (will be filtered)
}
# Sample size m for the within_unique calculation
m = 2
# Relation set - only "related" relations will create edges in adjacency
relation_set = frozenset(["related"])
ARGS = {
"sub_to_essay": sub_to_essay,
"pair_rel": pair_rel,
"m": m,
"relation_set": relation_set,
}
- 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 float, 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
|
| build_clusters |
Not yet run unverified (harvested, no recorded run) |
mungg/argument_collapse/src/argument_collapse/cluster.py code served (permissive licence) · get_code("7d061e7003a2a8e6") How it ran |
| select_llm_representatives |
Not yet run unverified (harvested, no recorded run) |
mungg/argument_collapse/src/argument_collapse/cluster.py code served (permissive licence) · get_code("c2b600030962f3b0") How it ran |