SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2603.22352 · 2026

WIST: Web-Grounded Iterative Self-Play Tree for Domain-Targeted Reasoning Improvement

Pengfei Li, Shijie Wang, Biqing Qi, Junqi Gao, Yuqiang Li, Jianxing Liu, Fangyuan Li

arXiv · PDF · Open in the Atlas

Code that ran

13 of 19 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 11 failures of our instrument; 6 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2603.22352.json · badge: /api/ran/2603.22352.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
lfy-123/WIST canonical (classifier label)
classifier basis: census
13 ran · 6 no recorded run
FunctionStatusWhere it lives
best_wiki_match Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/Tree.py
code served (permissive licence) · get_code("8fc07cac16dfc157")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, 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
from typing import List, Dict, Any, Optional, Tuple

ARGS = {
    "label": "Machine Learning Model",
    "wiki_keys": [
        "Machine Learning",
        "Deep Neural Networks",
        "Artificial Intelligence",
        "Computer Vision",
        "Natural Language Processing"
    ]
}
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
clean_paragraphs Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/clean_utils.py
code served (permissive licence) · get_code("d05a8d5f53ca7fe1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

# Define stopwords set for testing
stopwords = {
    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
    'of', 'with', 'by', 'from', 'is', 'are', 'was', 'were', 'be', 'been',
    'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
    'could', 'should', 'may', 'might', 'must', 'can', 'this', 'that',
    'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they'
}

# Create sample paragraphs with varied content
paragraphs = [
    "Home page navigation menu main content area.",
    "This is the first real sentence with actual content about a topic.",
    "Another paragraph discussing the main subject matter with proper sentences.",
    "Some mathematical discussion involving formulas and equations here.",
    "$\\frac{1}{2}$ and other equation fragments.",
    "Final paragraph with concluding thoughts on the material.",
    "Copyright 2023 all rights reserved privacy policy terms of service.",
    "Contact us for more information about our services."
]

ARGS = {
    'paragraphs': paragraphs,
    'stopwords': stopwords,
    'keep_formula_window': 3,
    'min_sentence_len': 20,
    'url': 'https://example.com/article'
}
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
compute_approx_kl Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
lfy-123/WIST/openrlhf/models/utils.py
code served (permissive licence) · get_code("d6e23db8c6a74238")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 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)

# Create small log probability tensors
# Shape: (batch_size=2, num_classes=4)
log_probs = torch.randn(2, 4)
log_probs_base = torch.randn(2, 4)

ARGS = {
    'log_probs': log_probs,
    'log_probs_base': log_probs_base,
    'kl_estimator': 'k1'
}
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 (2, 4) — shape (2, 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
compute_reward Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
lfy-123/WIST/openrlhf/models/utils.py
code served (permissive licence) · get_code("812f2e3f5cda7c93")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 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)

# Analyzing the function:
# - r: Union[torch.Tensor, float] - used with .clamp() and .unsqueeze(1), so torch.Tensor
# - kl_coef: float - compared and used in multiplication
# - kl: Union[torch.Tensor, list[torch.Tensor]] - used with operations like size(), long(), fliplr(), argmax(), scatter_
# - action_mask: Optional[torch.Tensor] - used with .size(1), .long(), .fliplr(), .argmax()
# - reward_clip_range: Tuple[float, float] - checked in if statement

# The function operates on 2D tensors with shape [batch, seq_len]
batch_size = 2
seq_len = 4

# r: reward tensor, shape [batch]
r = torch.randn(batch_size)

# kl_coef: coefficient for KL divergence penalty
kl_coef = 0.5

# kl: KL divergence tensor, shape [batch, seq_len]
kl = torch.randn(batch_size, seq_len)

# action_mask: binary mask indicating valid positions, shape [batch, seq_len]
# Values should be mostly 1s with 0s at the end to mark sequence boundaries
action_mask = torch.ones(batch_size, seq_len)
action_mask[0, 2:] = 0  # First sequence ends at index 1
action_mask[1, 3:] = 0  # Second sequence ends at index 2

# reward_clip_range: tuple for clipping rewards
reward_clip_range = (-1.0, 1.0)

ARGS = {
    "r": r,
    "kl_coef": kl_coef,
    "kl": kl,
    "action_mask": action_mask,
    "reward_clip_range": reward_clip_range,
}
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 (2, 4) — shape (2, 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
fetch_page_text Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/clean_utils.py
code served (permissive licence) · get_code("2ee2729eaeb1d3ba")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 requests
from unittest.mock import Mock, patch

# Mock the requests.get call to avoid actual network requests
mock_response = Mock()
mock_response.text = "<html><body>Sample webpage text</body></html>"
mock_response.apparent_encoding = "utf-8"
mock_response.raise_for_status = Mock()

# Construct valid arguments
ARGS = {
    "url": "https://example.com",
    "timeout": 10
}

# Patch requests.get to return our mock response
requests.get = Mock(return_value=mock_response)
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
requests — 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
log_probs_from_logits Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
lfy-123/WIST/openrlhf/models/utils.py
code served (permissive licence) · get_code("75afa2affd2a8e36")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 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
import torch.nn as nn

torch.manual_seed(0)

# Create small tensors for testing
# logits: shape (batch_size, seq_len, vocab_size) = (2, 3, 4)
# labels: shape (batch_size, seq_len) = (2, 3)
batch_size = 2
seq_len = 3
vocab_size = 4

logits = torch.randn(batch_size, seq_len, vocab_size, dtype=torch.float32)
labels = torch.randint(0, vocab_size, (batch_size, seq_len), dtype=torch.long)
temperature = 1.0

ARGS = {
    "logits": logits,
    "labels": labels,
    "temperature": temperature,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flash_attn, 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 (2, 3) — shape (2, 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
normalize_wiki_title Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/worker_web.py
code served (permissive licence) · get_code("f1cec62813419507")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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.

# Setup code for normalize_wiki_title function

ARGS = {
    "s": "the quick brown fox and the lazy dog"
}
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
search_and_fetch_grouped Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/search_pipeline.py
code served (permissive licence) · get_code("c987e22caed3c78a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, 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 json
from typing import Union, List, Dict, Any, Optional

# Set up minimal environment variables
os.environ['SEARCHCANS_TOKEN'] = 'test_searchcans_token_12345'
os.environ['DEEPCRAWL_API_KEY'] = 'test_deepcrawl_key_12345'
os.environ['SEARCHCANS_API'] = 'https://searchcans.youxikuang.cn/api/search'
os.environ['DEEPCRAWL_READ_API'] = 'https://api.deepcrawl.dev/read'

# Build minimal stand-in functions that the function calls
def validate_language(content: str, type: str = 'content', link: str = '') -> bool:
    """Minimal stand-in for validate_language check"""
    return len(content.strip()) > 100

def fetch_and_clean(url: str) -> str:
    """Minimal stand-in for fetch_and_clean fallback"""
    return "Sample content from " + url + " with enough length to pass validation checks"

# Inject these into the module namespace so they're available
import sys
current_module = sys.modules[__name__]
current_module.validate_language = validate_language
current_module.fetch_and_clean = fetch_and_clean

# Define ARGS with valid values for all parameters
ARGS = {
    'keywords': ['python tutorial', 'machine learning basics'],
    'engine': 'bing',
    'page': 1,
    'timeout_ms': 10000,
    'keyword_workers': 2,
    'fetch_workers': 4,
    'per_keyword_max_items': 5,
    'searchcans_token': 'test_token_abc123',
    'deepcrawl_api_key': 'test_key_xyz789',
    'temp_search_path': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
requests, tqdm — 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
search_mwmbl Ran
ran, honoured the contract we drafted
lfy-123/WIST/knowledge_tree/worker_web.py
code served (permissive licence) · get_code("bb0ef9b6b9406010")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import requests
from unittest.mock import Mock, patch
from typing import Dict, List

# Mock the requests.get call to avoid actual network requests
def create_mock_search_response():
    """Create a mock response object for the mwmbl API"""
    mock_response = Mock()
    mock_response.json.return_value = [
        {
            'title': 'Example Result 1',
            'url': 'https://example.com/page1',
            'href': None
        },
        {
            'title': ['Part ', {'value': 'of '}, 'Title'],
            'url': 'https://example.com/page2',
        },
        {
            'title': None,
            'url': 'https://example.com/page3',
        },
        {
            'title': '  Whitespace Title  ',
            'href': 'https://example.com/page4',
        }
    ]
    mock_response.raise_for_status.return_value = None
    return mock_response

# Patch requests.get to return our mock response
with patch('requests.get', return_value=create_mock_search_response()):
    pass

ARGS = {
    'query': 'python programming',
    'count': 10,
    'timeout': 20
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
requests — 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
show_path Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/utils.py
code served (permissive licence) · get_code("2978c7a7d0ce7c14")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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.

class Node:
    def __init__(self, name):
        self.name = name

# Create a path with nodes
root_node = Node('Root')
node1 = Node('Step1')
node2 = Node('Step2')
node3 = Node('Step3')

path = [root_node, node1, node2, node3]

ARGS = {
    'path': 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 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
split_path Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/utils.py
code served (permissive licence) · get_code("32ca89798c575b9e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function:
# - split_path(path_str) takes a string path_str
# - It splits by ' -> ' delimiter
# - Returns a list of names

# Construct a valid path string with ' -> ' delimiters
path_str = "module1 -> module2 -> module3"

ARGS = {
    "path_str": path_str
}
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
string_similarity Ran
ran, honoured the contract we drafted
lfy-123/WIST/knowledge_tree/Tree.py
code served (permissive licence) · get_code("e987ae3f372f129b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 re
from difflib import SequenceMatcher

def _normalize_label_for_similarity(s: str) -> str:
    if not s:
        return ''
    s = s.lower()
    s = re.sub('[^a-z0-9]+', ' ', s)
    s = ' '.join(s.split())
    return s

def string_similarity(str1: str, str2: str) -> float:
    s1 = _normalize_label_for_similarity(str1)
    s2 = _normalize_label_for_similarity(str2)
    if not s1 or not s2:
        return 0.0
    base_sim = SequenceMatcher(None, s1, s2).ratio()
    len_ratio = min(len(s1), len(s2)) / max(len(s1), len(s2))
    return base_sim * len_ratio

ARGS = {
    "str1": "Hello World 123",
    "str2": "hello-world-123"
}
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 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
strip_all_markdown_links Ran
ran; our contract draft was wrong, not the code
lfy-123/WIST/knowledge_tree/search_pipeline.py
code served (permissive licence) · get_code("f6a6ad219ca042d3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned 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 re

def strip_all_markdown_links(md: str) -> str:
    """
    删除 Markdown 中所有超链接(含图片链接、嵌套链接)。
    - [text](url) -> text
    - ![alt](url) -> alt
    - [![alt](...)](url) -> alt
    不保留任何 URL。
    """
    if not md:
        return md
    md = md.replace('\xa0', ' ')
    md = re.sub('\\[\\s*(!\\[[^\\]]*\\]\\([^)]+\\))\\s*\\]\\([^)]+\\)', '\\1', md)
    prev = None
    while prev != md:
        prev = md
        md = re.sub('!\\[([^\\]]*)\\]\\([^)]+\\)', '\\1', md)
        md = re.sub('\\[([\\s\\S]*?)\\]\\([^)]+\\)', '\\1', md)
    md = re.sub('[ \\t]+\\n', '\n', md)
    md = re.sub('\\n{3,}', '\n\n', md)
    return md

# Test case 1: Simple markdown link
test_md_1 = "Check out [this link](https://example.com) for more info"

# Test case 2: Image markdown link
test_md_2 = "Here is an image ![alt text](https://example.com/image.png)"

# Test case 3: Nested image link
test_md_3 = "Click the image [![alt](https://example.com/img.png)](https://example.com)"

# Test case 4: Multiple links
test_md_4 = "Visit [link1](url1) and [link2](url2) for details"

# Test case 5: Empty string
test_md_5 = ""

# Test case 6: No markdown
test_md_6 = "Plain text with no links"

# Test case 7: With non-breaking space
test_md_7 = "Text\xa0with\xa0spaces [link](url)"

# Test case 8: Multiple newlines
test_md_8 = "Line1\n\n\n\nLine2 [text](url)"

ARGS = {
    "md": test_md_1
}
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
build_expansion_prompt_math Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/knowledge_tree/prompts.py
code served (permissive licence) · get_code("2322cff6b05213f3")
How it ran

no invocation recorded.

build_expansion_prompt_med Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/knowledge_tree/prompts.py
code served (permissive licence) · get_code("b43e96775fe96be3")
How it ran

no invocation recorded.

build_expansion_prompt_phy Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/knowledge_tree/prompts.py
code served (permissive licence) · get_code("1a0461b2603acbe0")
How it ran

no invocation recorded.

get_tensor_in_current_ring_attn_rank Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/openrlhf/models/ring_attn_utils.py
code served (permissive licence) · get_code("5110d3bb195169a8")
How it ran

no invocation recorded.

reset_ring_attn_position_ids Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/openrlhf/models/ring_attn_utils.py
code served (permissive licence) · get_code("e93117d99aa6b210")
How it ran

no invocation recorded.

search_searxng Not yet run
unverified (harvested, no recorded run)
lfy-123/WIST/knowledge_tree/utils.py
code served (permissive licence) · get_code("6d2dffb441337e76")
How it ran

no invocation recorded.

Also present in other papers' code

Of 19 samples lifted from this paper's linked repositories, 19 carry a function identity and 0 do not. Of the 19 distinct functions with an identity, 4 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 0 the same month, 4 later) and 15 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
reset_ring_attn_position_ids 15 other papers
14 dated earlier, 1 later
2306.00398 (2023-06)
Preference-grounded Token-level Guidance for Language Model Fine-tuning
2402.09345 (2024-02)
InfoRM: Mitigating Reward Hacking in RLHF via Information-Theoretic Reward Modeling
2404.18922 (2024-04)
DPO Meets PPO: Reinforced Token Optimization for RLHF
and 12 more not named here
log_probs_from_logits 4 other papers
3 dated earlier, 1 later
2502.14768 (2025-02)
Logic-RL: Unleashing LLM Reasoning with Rule-Based Reinforcement Learning
2504.07912 (2025-04)
Echo Chamber: RL Post-training Amplifies Behaviors Learned in Pretraining
2505.15456 (2025-05)
Teaching Language Models to Evolve with Users: Dynamic Profile Modeling for Personalized Alignment
and 1 more not named here
compute_reward 2 other papers
1 dated earlier, 1 later
2502.14768 (2025-02)
Logic-RL: Unleashing LLM Reasoning with Rule-Based Reinforcement Learning
2606.09124 (2026-06)
A Regret Minimization Framework on Preference Learning in Large Language Models
get_tensor_in_current_ring_attn_rank 2 other papers
1 dated earlier, 1 later
2502.14768 (2025-02)
Logic-RL: Unleashing LLM Reasoning with Rule-Based Reinforcement Learning
2606.09124 (2026-06)
A Regret Minimization Framework on Preference Learning in Large Language Models

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Recent progress in reinforcement learning with verifiable rewards (RLVR) offers a practical path to self-improvement of language models, but existing methods face a key tradeoff: endogenous self-play can drift over iterations, while corpus-grounded approaches rely on curated data environments. We present WIST, a Web-grounded Iterative Self-play Tree framework for domain-targeted reasoning improvement that learns directly from the open web without requiring any pre-arranged domain corpus. WIST incrementally expands a domain tree for exploration, and retrieves and cleans path-consistent web corpus to construct a controllable training environment. It then performs Challenger-Solver self-play with verifiable rewards, and feeds learnability signals back to update node posteriors and guide subsequent exploration through an adaptive curriculum. Across four backbones, WIST consistently improves over the base models and typically outperforms both purely endogenous self-evolution and corpus-grounded selfplay baselines, with the Overall gains reaching +9.8 (Qwen3-4B-Base) and +9.7 (OctoThinker-8B). WIST is also domain-steerable, improving Qwen3-8B-Base by +14.79 in medicine and Qwen3-4B-Base by +5.28 on PhyBench. Ablations further confirm the importance of WIST's key components for stable open-web learning. Our Code is available at https: //github.com/lfy-123/WIST.

For agents

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

get_harvested_code_for_paper("2603.22352")
get_code_for_paper("2603.22352")
have("2603.22352")

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

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

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

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

Connect an agent — have() is free.