Publish verified ToolElite model/data asset

.gitattributes

@@ -58,3 +58,29 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+raw_data/1.json filter=lfs diff=lfs merge=lfs -text
+raw_data/10.json filter=lfs diff=lfs merge=lfs -text
+raw_data/11.json filter=lfs diff=lfs merge=lfs -text
+raw_data/12.json filter=lfs diff=lfs merge=lfs -text
+raw_data/13.json filter=lfs diff=lfs merge=lfs -text
+raw_data/14.json filter=lfs diff=lfs merge=lfs -text
+raw_data/15.json filter=lfs diff=lfs merge=lfs -text
+raw_data/16.json filter=lfs diff=lfs merge=lfs -text
+raw_data/17.json filter=lfs diff=lfs merge=lfs -text
+raw_data/18.json filter=lfs diff=lfs merge=lfs -text
+raw_data/19.json filter=lfs diff=lfs merge=lfs -text
+raw_data/2.json filter=lfs diff=lfs merge=lfs -text
+raw_data/20.json filter=lfs diff=lfs merge=lfs -text
+raw_data/21.json filter=lfs diff=lfs merge=lfs -text
+raw_data/22.json filter=lfs diff=lfs merge=lfs -text
+raw_data/23.json filter=lfs diff=lfs merge=lfs -text
+raw_data/24.json filter=lfs diff=lfs merge=lfs -text
+raw_data/25.json filter=lfs diff=lfs merge=lfs -text
+raw_data/3.json filter=lfs diff=lfs merge=lfs -text
+raw_data/4.json filter=lfs diff=lfs merge=lfs -text
+raw_data/5.json filter=lfs diff=lfs merge=lfs -text
+raw_data/6.json filter=lfs diff=lfs merge=lfs -text
+raw_data/7.json filter=lfs diff=lfs merge=lfs -text
+raw_data/8.json filter=lfs diff=lfs merge=lfs -text
+raw_data/9.json filter=lfs diff=lfs merge=lfs -text
+search_r1_corpus.jsonl filter=lfs diff=lfs merge=lfs -text

NOTICE.md

@@ -0,0 +1,4 @@
+Wikipedia contributors. Article URLs and author histories: see link fields in raw_data/*.json.
+Modified by ToolElite: markup removal and passage segmentation.
+Text: CC BY-SA 4.0, https://creativecommons.org/licenses/by-sa/4.0/
+Original scripts retained as supplied; no separate code license asserted.

README.md

@@ -0,0 +1,54 @@
+---
+license: cc-by-sa-4.0
+language:
+- en
+tags:
+- math
+- retrieval
+- search-r1
+- toolelite
+configs:
+- config_name: corpus
+  default: true
+  data_files:
+  - split: train
+    path: search_r1_corpus.jsonl
+---
+
+# 数学百科常识向量检索数据库 — ToolElite / wiki_math
+
+本仓库用于服务 ToolElite 的 search 工具，为多轮数学推理提供外部知识检索。
+内容为数学百科知识、概念、背景与相关常识。
+
+发布内容是向量检索数据库的 **corpus、原始数据与构建脚本**；本地文件夹未包含 embedding、FAISS 索引或检索编码器权重，使用前需构建索引。
+
+## Corpus 格式
+
+`search_r1_corpus.jsonl` 共 **573,011** 个片段，字段为 `id` (string), `contents` (string)。
+采用 Search-R1 本地数据库的 JSONL corpus 结构：每行一条记录，`id` 为按行递增的字符串，
+`contents` 为 `"文章标题"\n正文片段`。
+字段与 ToolElite 本地 corpus 加载器匹配；应保持 corpus 行顺序与向量索引对应。
+[Search-R1](https://github.com/PeterGriffinJin/Search-R1) 为格式/流程参考，不是本语料的作者。
+
+原始文件保存在 `raw_data/`，不与主 corpus 混作训练行；原始处理脚本按原样保存，可能含原机器绝对路径，运行前需指定本机输入/输出路径。
+`asset-summary.json` 与 `publication-manifest.json` 提供结构摘要、大小和 SHA256 校验。
+
+## 下载与接入
+
+```bash
+hf download BitZone910/wiki_math --repo-type dataset --local-dir data/wiki_math
+
+# 在 ToolElite 项目环境中，将 corpus 编码为 FAISS 索引
+python -m toolelite.retrieval.general.build_index \
+  --corpus_path data/wiki_math/search_r1_corpus.jsonl \
+  --save_dir data/wiki_math/index --faiss_type Flat \
+  --device cpu --no-faiss_gpu --batch_size 128
+```
+
+检索服务的 `general_corpus_path` 指向上述 corpus，`general_index_path` 指向生成的 `e5_Flat.index`，
+并加载与建索引相同的 E5 编码器。两个仓库可以各自建索引；若合并 corpus，需重新编号并重新建索引。
+
+## 来源、许可与处理
+
+来自本地数学 Wikipedia 抓取快照；25 个原始 JSON 的 `link` 保留文章 URL，页面历史可用于作者归属。原始下载地址和抓取时间未记录。处理后文本遵循 Wikipedia 的 CC BY-SA 4.0 归属与相同方式共享要求；本文与原始链接一并保留归属。[Wikimedia 条款](https://foundation.wikimedia.org/wiki/Policy:Terms_of_Use)。
+清洗、移除标记及按片段切分会改变原文本；详见仓库处理脚本。此数据库不保证所有陈述无误，检索结果需结合推理核实。

asset-summary.json

@@ -0,0 +1,10 @@
+{
+  "rows": 573011,
+  "fields": [
+    "contents",
+    "id"
+  ],
+  "positional_ids": true,
+  "embeddings_included": false,
+  "faiss_index_included": false
+}

build_search_r1_corpus.py

@@ -0,0 +1,484 @@
+"""Build a Search-R1-compatible passage corpus from the local Math Wikipedia dump.
+
+This script intentionally uses only the Python standard library. It reads the
+25 source JSON files in numeric order and writes one JSON object per passage.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+import os
+import re
+from collections import Counter
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any, Iterable, Optional
+from urllib.parse import unquote, urlsplit
+
+
+BASE_DIR = Path(r"C:\Users\lenovo\Desktop\wiki_math")
+INPUT_DIR = BASE_DIR / "raw_data"
+OUTPUT_PATH = BASE_DIR / "search_r1_corpus.jsonl"
+TEMP_OUTPUT_PATH = BASE_DIR / "search_r1_corpus.jsonl.tmp"
+INPUT_FILES = tuple(INPUT_DIR / f"{number}.json" for number in range(1, 26))
+
+TARGET_PASSAGE_WORDS = 100
+MIN_PASSAGE_WORDS = 50
+PROGRESS_INTERVAL = 1_000
+
+TITLE_NAMESPACE_PREFIXES = (
+    "file:",
+    "image:",
+    "category:",
+    "template:",
+    "wikipedia:",
+    "portal:",
+    "help:",
+    "mediawiki:",
+    "user:",
+    "talk:",
+    "draft:",
+)
+PROTECTION_KEYWORDS = (
+    "semi-protected",
+    "protected",
+    "extended confirmed protected",
+)
+REMOVED_WIKILINK_NAMESPACES = ("file:", "image:", "category:")
+
+BLOCK_TAGS = {
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "br",
+    "caption",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "td",
+    "th",
+    "tr",
+    "ul",
+}
+INVISIBLE_FORMAT_CHARS = str.maketrans(
+    {
+        "\u200b": None,  # zero-width space
+        "\u200c": None,  # zero-width non-joiner
+        "\u200d": None,  # zero-width joiner
+        "\u200e": None,  # left-to-right mark (for example, ‎)
+        "\u200f": None,  # right-to-left mark
+        "\ufeff": None,  # byte-order mark / zero-width no-break space
+    }
+)
+
+WIKILINK_RE = re.compile(r"\[\[([^\[\]]*)\]\]")
+EXTERNAL_LINK_RE = re.compile(
+    r"\[https?://[^\s\]]+(?:\s+([^\]]*?))?\]", re.IGNORECASE
+)
+BARE_URL_RE = re.compile(r"https?://[^\s<>\[\]\"']+", re.IGNORECASE)
+WHITESPACE_RE = re.compile(r"\s+")
+SPACE_BEFORE_PUNCTUATION_RE = re.compile(r"\s+([,.;:!?])")
+CLOSING_SENTENCE_CHARS = frozenset("\"'\u2019\u201d)]}")
+TRAILING_URL_PUNCTUATION = frozenset(".,;:!?)]}")
+
+
+class _HTMLTextExtractor(HTMLParser):
+    """Drop markup while retaining visible text and sensible word boundaries."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+
+    def handle_starttag(
+        self, tag: str, attrs: list[tuple[str, Optional[str]]]
+    ) -> None:
+        del attrs
+        if tag.lower() in BLOCK_TAGS:
+            self.parts.append(" ")
+
+    def handle_startendtag(
+        self, tag: str, attrs: list[tuple[str, Optional[str]]]
+    ) -> None:
+        self.handle_starttag(tag, attrs)
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag.lower() in BLOCK_TAGS:
+            self.parts.append(" ")
+
+    def handle_data(self, data: str) -> None:
+        self.parts.append(data)
+
+    def get_text(self) -> str:
+        return "".join(self.parts)
+
+
+def normalize_whitespace(text: str) -> str:
+    """Collapse spaces, tabs, and newlines into a single ASCII space."""
+
+    normalized = WHITESPACE_RE.sub(" ", text).strip()
+    return SPACE_BEFORE_PUNCTUATION_RE.sub(r"\1", normalized)
+
+
+def strip_html_and_decode_entities(text: str) -> str:
+    """Decode entities, remove HTML tags, and remove invisible format marks."""
+
+    decoded = html.unescape(text).translate(INVISIBLE_FORMAT_CHARS)
+    parser = _HTMLTextExtractor()
+    parser.feed(decoded)
+    parser.close()
+    return parser.get_text().translate(INVISIBLE_FORMAT_CHARS)
+
+
+def remove_balanced_templates(text: str) -> str:
+    """Remove balanced, possibly nested, ``{{...}}`` template spans.
+
+    An unmatched opening marker is preserved instead of discarding the rest of
+    an article. This protects useful text when malformed source markup appears.
+    """
+
+    spans: list[tuple[int, int]] = []
+    stack: list[int] = []
+    outer_start = -1
+    index = 0
+
+    while index < len(text) - 1:
+        pair = text[index : index + 2]
+        if pair == "{{":
+            if not stack:
+                outer_start = index
+            stack.append(index)
+            index += 2
+            continue
+        if pair == "}}" and stack:
+            stack.pop()
+            index += 2
+            if not stack:
+                spans.append((outer_start, index))
+                outer_start = -1
+            continue
+        index += 1
+
+    if not spans:
+        return text
+
+    parts: list[str] = []
+    cursor = 0
+    for start, end in spans:
+        parts.append(text[cursor:start])
+        parts.append(" ")
+        cursor = end
+    parts.append(text[cursor:])
+    return "".join(parts)
+
+
+def _replace_wikilink(match: re.Match[str]) -> str:
+    inner = match.group(1).strip()
+    if not inner:
+        return ""
+
+    target = inner.split("|", 1)[0].strip()
+    if target.casefold().startswith(REMOVED_WIKILINK_NAMESPACES):
+        return ""
+
+    if "|" in inner:
+        return inner.rsplit("|", 1)[1].strip()
+    return inner
+
+
+def clean_wikilinks(text: str) -> str:
+    """Resolve normal wikilinks and remove media/category wikilink blocks."""
+
+    while True:
+        updated, replacements = WIKILINK_RE.subn(_replace_wikilink, text)
+        text = updated
+        if replacements == 0:
+            return text
+
+
+def clean_external_links(text: str) -> str:
+    """Keep bracketed external-link labels and remove unlabeled links."""
+
+    def replace(match: re.Match[str]) -> str:
+        label = match.group(1)
+        return label.strip() if label else ""
+
+    return EXTERNAL_LINK_RE.sub(replace, text)
+
+
+def remove_bare_urls(text: str) -> str:
+    """Remove bare HTTP(S) URLs without swallowing adjacent sentence marks."""
+
+    def replace(match: re.Match[str]) -> str:
+        url = match.group(0)
+        trailing: list[str] = []
+        while url and url[-1] in TRAILING_URL_PUNCTUATION:
+            trailing.append(url[-1])
+            url = url[:-1]
+        return "".join(reversed(trailing))
+
+    return BARE_URL_RE.sub(replace, text)
+
+
+def clean_content(content: str) -> str:
+    """Apply all requested article-body cleaning steps."""
+
+    text = strip_html_and_decode_entities(content)
+    text = remove_balanced_templates(text)
+    text = clean_wikilinks(text)
+    text = clean_external_links(text)
+    text = remove_bare_urls(text)
+    return normalize_whitespace(text)
+
+
+def title_from_link(link: str) -> str:
+    """Extract and decode the page name following ``/wiki/`` in a URL."""
+
+    path = unquote(urlsplit(link).path)
+    marker = "/wiki/"
+    marker_index = path.casefold().find(marker)
+    if marker_index < 0:
+        return ""
+    page_name = path[marker_index + len(marker) :]
+    return normalize_whitespace(page_name.replace("_", " "))
+
+
+def clean_title(title: str, link: str) -> str:
+    """Clean a title and use its URL page name when the result is empty."""
+
+    cleaned = normalize_whitespace(strip_html_and_decode_entities(title))
+    return cleaned or title_from_link(link)
+
+
+def initial_filter_reason(article: Any) -> Optional[str]:
+    """Return the first matching raw-record filter reason, if any."""
+
+    if not isinstance(article, dict):
+        return "invalid_record"
+
+    raw_title = article.get("title")
+    raw_link = article.get("link")
+    raw_content = article.get("content")
+
+    title = "" if raw_title is None else str(raw_title)
+    link = "" if raw_link is None else str(raw_link)
+    folded_title = title.strip().casefold()
+    folded_link = link.casefold()
+
+    if folded_title.startswith(TITLE_NAMESPACE_PREFIXES):
+        return "title_namespace_prefix"
+    if any(keyword in folded_title for keyword in PROTECTION_KEYWORDS):
+        return "title_protection_keyword"
+    if raw_content is None or len(str(raw_content).strip()) < 50:
+        return "content_empty_or_under_50_chars"
+    if "/wiki/file:" in folded_link or "/wiki/image:" in folded_link:
+        return "file_or_image_link"
+    return None
+
+
+def split_sentences(text: str) -> list[str]:
+    """Split after .?! plus optional closing quotes/brackets and whitespace."""
+
+    sentences: list[str] = []
+    sentence_start = 0
+    index = 0
+
+    while index < len(text):
+        if not text[index].isspace():
+            index += 1
+            continue
+
+        previous = index - 1
+        while (
+            previous >= sentence_start
+            and text[previous] in CLOSING_SENTENCE_CHARS
+        ):
+            previous -= 1
+
+        if previous >= sentence_start and text[previous] in ".?!":
+            sentence = text[sentence_start:index].strip()
+            if sentence:
+                sentences.append(sentence)
+            while index < len(text) and text[index].isspace():
+                index += 1
+            sentence_start = index
+            continue
+
+        index += 1
+
+    remainder = text[sentence_start:].strip()
+    if remainder:
+        sentences.append(remainder)
+    return sentences
+
+
+def word_count(text: str) -> int:
+    return len(text.split())
+
+
+def make_passages(text: str) -> list[str]:
+    """Greedily accumulate sentences into Search-R1 retrieval passages."""
+
+    if word_count(text) < MIN_PASSAGE_WORDS:
+        return []
+
+    passages: list[str] = []
+    current_sentences: list[str] = []
+    current_words = 0
+
+    for sentence in split_sentences(text):
+        current_sentences.append(sentence)
+        current_words += word_count(sentence)
+        if current_words >= TARGET_PASSAGE_WORDS:
+            passages.append(" ".join(current_sentences))
+            current_sentences = []
+            current_words = 0
+
+    if current_sentences:
+        remainder = " ".join(current_sentences)
+        if current_words < MIN_PASSAGE_WORDS and passages:
+            passages[-1] = f"{passages[-1]} {remainder}"
+        else:
+            passages.append(remainder)
+
+    return passages
+
+
+def load_documents(path: Path) -> list[Any]:
+    """Load either the observed {documents: [...]} root or a top-level array."""
+
+    with path.open("r", encoding="utf-8") as source:
+        data = json.load(source)
+
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict) and isinstance(data.get("documents"), list):
+        return data["documents"]
+    raise ValueError(
+        f"{path} must contain a JSON array or an object with a 'documents' array"
+    )
+
+
+def verify_input_files(paths: Iterable[Path]) -> None:
+    missing = [str(path) for path in paths if not path.is_file()]
+    if missing:
+        formatted = "\n  ".join(missing)
+        raise FileNotFoundError(f"Missing input files:\n  {formatted}")
+
+
+def print_statistics(
+    original_articles: int,
+    retained_articles: int,
+    filter_counts: Counter[str],
+    passage_count: int,
+) -> None:
+    filtered_articles = sum(filter_counts.values())
+    average = passage_count / retained_articles if retained_articles else 0.0
+
+    print("\nCompleted corpus generation.")
+    print(f"Original articles: {original_articles}")
+    print(f"Retained articles: {retained_articles}")
+    print(f"Filtered articles: {filtered_articles}")
+    print("Filtered by reason (mutually exclusive):")
+    for reason in (
+        "invalid_record",
+        "title_namespace_prefix",
+        "title_protection_keyword",
+        "content_empty_or_under_50_chars",
+        "file_or_image_link",
+        "cleaned_content_under_50_words",
+    ):
+        print(f"  {reason}: {filter_counts[reason]}")
+    print(f"Generated passages: {passage_count}")
+    print(f"Average passages per retained article: {average:.4f}")
+    print(f"Output file: {OUTPUT_PATH}")
+
+
+def build_corpus() -> None:
+    """Read, clean, split, and atomically write the complete passage corpus."""
+
+    verify_input_files(INPUT_FILES)
+
+    processed_articles = 0
+    retained_articles = 0
+    passage_count = 0
+    filter_counts: Counter[str] = Counter()
+
+    try:
+        with TEMP_OUTPUT_PATH.open("w", encoding="utf-8", newline="\n") as output:
+            for input_path in INPUT_FILES:
+                documents = load_documents(input_path)
+                for article in documents:
+                    processed_articles += 1
+                    reason = initial_filter_reason(article)
+
+                    if reason is not None:
+                        filter_counts[reason] += 1
+                    else:
+                        assert isinstance(article, dict)
+                        raw_content = str(article["content"])
+                        raw_title = "" if article.get("title") is None else str(article["title"])
+                        raw_link = "" if article.get("link") is None else str(article["link"])
+
+                        cleaned_content = clean_content(raw_content)
+                        passages = make_passages(cleaned_content)
+                        if not passages:
+                            filter_counts["cleaned_content_under_50_words"] += 1
+                        else:
+                            title = clean_title(raw_title, raw_link)
+                            retained_articles += 1
+                            for passage in passages:
+                                record = {
+                                    "id": str(passage_count),
+                                    "contents": f'"{title}"\n{passage}',
+                                }
+                                output.write(json.dumps(record, ensure_ascii=False))
+                                output.write("\n")
+                                passage_count += 1
+
+                    if processed_articles % PROGRESS_INTERVAL == 0:
+                        print(
+                            f"Processed {processed_articles} articles, "
+                            f"generated {passage_count} passages..."
+                        )
+
+        os.replace(TEMP_OUTPUT_PATH, OUTPUT_PATH)
+    except BaseException:
+        try:
+            TEMP_OUTPUT_PATH.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+
+    print_statistics(
+        original_articles=processed_articles,
+        retained_articles=retained_articles,
+        filter_counts=filter_counts,
+        passage_count=passage_count,
+    )
+
+
+if __name__ == "__main__":
+    build_corpus()

demo_generate_30.py

@@ -0,0 +1,110 @@
+"""Generate and print a 30-passage Search-R1 corpus demo."""
+
+import json
+import os
+import sys
+from collections import Counter
+
+import build_search_r1_corpus as corpus_builder
+
+
+DEMO_PASSAGE_LIMIT = 30
+DEMO_OUTPUT_PATH = corpus_builder.BASE_DIR / "search_r1_corpus_demo.jsonl"
+DEMO_TEMP_PATH = corpus_builder.BASE_DIR / "search_r1_corpus_demo.jsonl.tmp"
+
+
+def main() -> None:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+    corpus_builder.verify_input_files(corpus_builder.INPUT_FILES)
+
+    jsonl_lines = []
+    scanned_articles = 0
+    retained_articles = 0
+    filter_counts = Counter()
+
+    try:
+        with DEMO_TEMP_PATH.open(
+            "w", encoding="utf-8", newline="\n"
+        ) as output:
+            for input_path in corpus_builder.INPUT_FILES:
+                documents = corpus_builder.load_documents(input_path)
+
+                for article in documents:
+                    scanned_articles += 1
+                    reason = corpus_builder.initial_filter_reason(article)
+
+                    if reason is not None:
+                        filter_counts[reason] += 1
+                        continue
+
+                    raw_content = str(article["content"])
+                    raw_title = (
+                        ""
+                        if article.get("title") is None
+                        else str(article["title"])
+                    )
+                    raw_link = (
+                        ""
+                        if article.get("link") is None
+                        else str(article["link"])
+                    )
+
+                    cleaned_content = corpus_builder.clean_content(raw_content)
+                    passages = corpus_builder.make_passages(cleaned_content)
+                    if not passages:
+                        filter_counts["cleaned_content_under_50_words"] += 1
+                        continue
+
+                    retained_articles += 1
+                    title = corpus_builder.clean_title(raw_title, raw_link)
+
+                    for passage in passages:
+                        passage_id = str(len(jsonl_lines))
+                        record = {
+                            "id": passage_id,
+                            "contents": f'"{title}"\n{passage}',
+                        }
+                        line = json.dumps(record, ensure_ascii=False)
+                        output.write(line)
+                        output.write("\n")
+                        jsonl_lines.append(line)
+
+                        if len(jsonl_lines) == DEMO_PASSAGE_LIMIT:
+                            break
+
+                    if len(jsonl_lines) == DEMO_PASSAGE_LIMIT:
+                        break
+
+                if len(jsonl_lines) == DEMO_PASSAGE_LIMIT:
+                    break
+
+        os.replace(DEMO_TEMP_PATH, DEMO_OUTPUT_PATH)
+    except BaseException:
+        try:
+            DEMO_TEMP_PATH.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+
+    print("=" * 80)
+    print(f"Search-R1 corpus demo: {len(jsonl_lines)} JSONL records")
+    print("=" * 80)
+    for line in jsonl_lines:
+        print(line)
+
+    print("=" * 80)
+    print("Demo summary")
+    print("=" * 80)
+    print(f"Scanned source articles: {scanned_articles}")
+    print(f"Articles contributing passages: {retained_articles}")
+    print(f"Filtered while scanning: {sum(filter_counts.values())}")
+    for reason, count in sorted(filter_counts.items()):
+        print(f"  {reason}: {count}")
+    print(f"Generated passages: {len(jsonl_lines)}")
+    print(f"Output file: {DEMO_OUTPUT_PATH}")
+
+
+if __name__ == "__main__":
+    main()

publication-manifest.json

@@ -0,0 +1,175 @@
+{
+  "schema_version": "toolelite.hf-publication.v1",
+  "repo_id": "BitZone910/wiki_math",
+  "repo_type": "dataset",
+  "visibility": "public",
+  "asset_id": "62d45b3423afbc1b88afbad41ce8bbd24872798d12c3a734b1006b9326dd329d",
+  "files": [
+    {
+      "path": "asset-summary.json",
+      "bytes": 166,
+      "sha256": "82482aeb6918ddd66df38282bc9af0fb2e013f090f438bd357d957f16352ec96"
+    },
+    {
+      "path": "build_search_r1_corpus.py",
+      "bytes": 14447,
+      "sha256": "7267bb5004d7536ba7e2c5ec91d587fb5b3c7cec07ca5a0ab0b18b8cabaf9a58"
+    },
+    {
+      "path": "demo_generate_30.py",
+      "bytes": 3662,
+      "sha256": "4c1030c4b578da78b758a1bf4274c7a6fd22fed553281d6f7e45f5028c55a35d"
+    },
+    {
+      "path": "NOTICE.md",
+      "bytes": 305,
+      "sha256": "8940071130fc94b88573476a90a5161093744b1d1d2f42514344ba30e9b1a892"
+    },
+    {
+      "path": "raw_data/1.json",
+      "bytes": 48240711,
+      "sha256": "d93207a924c221271c18ce74d3a8eac375edbe3b5de0828f3a1801bdb04b6607"
+    },
+    {
+      "path": "raw_data/10.json",
+      "bytes": 14459930,
+      "sha256": "89899b15fee5c1f4777edcdbbdaa1f707cca0b0609c89c7f7e1713ccbf3b507c"
+    },
+    {
+      "path": "raw_data/11.json",
+      "bytes": 13821228,
+      "sha256": "ff36acced0fcd104e98f95e9759bf481f417d10a5d5c14bb0822a1e4511c19d1"
+    },
+    {
+      "path": "raw_data/12.json",
+      "bytes": 21750967,
+      "sha256": "aa35601110ea2976b87f5f8e8460b65d16e88efbefff61eaf2792b23131f051d"
+    },
+    {
+      "path": "raw_data/13.json",
+      "bytes": 23249464,
+      "sha256": "7a7b0409ae480f242e4ce62ca0c6694710459c8df1169dad5f1105adc20050a2"
+    },
+    {
+      "path": "raw_data/14.json",
+      "bytes": 15485912,
+      "sha256": "5a25e5ef2c908adeb88692e7d306cdb84f6b31b84cf722a66b8a06664e11606b"
+    },
+    {
+      "path": "raw_data/15.json",
+      "bytes": 16017542,
+      "sha256": "74cbae286bcd8e9a6209fff2b6ce7d75fe18e478d0731957fdc47d32ad550f34"
+    },
+    {
+      "path": "raw_data/16.json",
+      "bytes": 17147104,
+      "sha256": "7a0b34fd181c86d6ff4a829f9ccf0a7fcf9f3e901ce07acadfabaf8fe9768617"
+    },
+    {
+      "path": "raw_data/17.json",
+      "bytes": 14880769,
+      "sha256": "d9caad660878bf5d198abb9020dc770ff26b2134e95a168d08f99018912c8dd3"
+    },
+    {
+      "path": "raw_data/18.json",
+      "bytes": 17188925,
+      "sha256": "f1f38fc7b9805972f3b67d47781088dea15d20c5b7a9fd39919c2a05248c9258"
+    },
+    {
+      "path": "raw_data/19.json",
+      "bytes": 15952857,
+      "sha256": "c3e236289285308934ba9800e846dbfc40c8c1e542bfe5329d76a3c2c42c3af2"
+    },
+    {
+      "path": "raw_data/2.json",
+      "bytes": 40525855,
+      "sha256": "e043d2600ec6d1d918184d3de6f9c848976bd3844418239acd3aac8b760fe958"
+    },
+    {
+      "path": "raw_data/20.json",
+      "bytes": 17354868,
+      "sha256": "bfab6793d569677ffa3c144bb79edf0592d92fcb5340432d31b4070123d150de"
+    },
+    {
+      "path": "raw_data/21.json",
+      "bytes": 15281958,
+      "sha256": "08284c3f5f9ee54132f297be27b1beecf5d7075c20b7ed1547014693236b85c4"
+    },
+    {
+      "path": "raw_data/22.json",
+      "bytes": 22178602,
+      "sha256": "e1a93e09ff5dc9522df1e1cbf82a79d8a8aefbdd9a7ba164cb83a8511c9508f6"
+    },
+    {
+      "path": "raw_data/23.json",
+      "bytes": 31585222,
+      "sha256": "9479a067a829872638999816d15d648f0a6e8117583697a18f18c93bfc4295b9"
+    },
+    {
+      "path": "raw_data/24.json",
+      "bytes": 17337513,
+      "sha256": "ed963df4a07a99781523da4f36ab8280da5fec51e7d24711f9782e77e1b29d0f"
+    },
+    {
+      "path": "raw_data/25.json",
+      "bytes": 31150026,
+      "sha256": "f11e79d3389a1bd71e8a17a87ccd069374bfcf568a01b0bfe2a3f53342a505b9"
+    },
+    {
+      "path": "raw_data/3.json",
+      "bytes": 34635903,
+      "sha256": "e70a3d6fc974a5037e6c260244dd121a1f4967b369b3779c4d2cd0790abf523e"
+    },
+    {
+      "path": "raw_data/4.json",
+      "bytes": 33715353,
+      "sha256": "2c00d592ff597a2f9b130a6dd577641e6219591cc92adc76d505d831d814ed30"
+    },
+    {
+      "path": "raw_data/5.json",
+      "bytes": 38107300,
+      "sha256": "bdf2661189b8454277cab44e73eadd318dfa32a37b80eaac6ed29dce68aee4a9"
+    },
+    {
+      "path": "raw_data/6.json",
+      "bytes": 25177537,
+      "sha256": "41c3faaf5e35e5f2c03ded20b82aa8d19dc4d3bec7114a86bac80906169d98e0"
+    },
+    {
+      "path": "raw_data/7.json",
+      "bytes": 21966253,
+      "sha256": "db4eb0237f24d77811eeca3d49469fd6a82f08513a9a525f1d8effc6b9a9241e"
+    },
+    {
+      "path": "raw_data/8.json",
+      "bytes": 21020296,
+      "sha256": "449d59e64c9d82957d39296c4a74b3c675f705f746c20fb971be36cdde79f43a"
+    },
+    {
+      "path": "raw_data/9.json",
+      "bytes": 27945214,
+      "sha256": "66dc8ca47e6accddcce08f4ba30515f9b6d46c995e27f4f59210facfad3a5706"
+    },
+    {
+      "path": "README.md",
+      "bytes": 2692,
+      "sha256": "3a50f327a432d14e87c6440eb74b8aa7262139da967a601c2da4439c030e8040"
+    },
+    {
+      "path": "search_r1_corpus.jsonl",
+      "bytes": 443937190,
+      "sha256": "741affc0363d4bad7e8871559dd6f849d5b19fd73a99e0124c100974c64255a7"
+    }
+  ],
+  "source_folder": "C:\\Users\\lenovo\\Desktop\\ToolElite_data_processing\\wiki_math",
+  "summary": {
+    "rows": 573011,
+    "fields": [
+      "contents",
+      "id"
+    ],
+    "positional_ids": true,
+    "embeddings_included": false,
+    "faiss_index_included": false
+  }
+}

raw_data/1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d93207a924c221271c18ce74d3a8eac375edbe3b5de0828f3a1801bdb04b6607
+size 48240711

raw_data/10.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89899b15fee5c1f4777edcdbbdaa1f707cca0b0609c89c7f7e1713ccbf3b507c
+size 14459930

raw_data/11.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff36acced0fcd104e98f95e9759bf481f417d10a5d5c14bb0822a1e4511c19d1
+size 13821228

raw_data/12.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa35601110ea2976b87f5f8e8460b65d16e88efbefff61eaf2792b23131f051d
+size 21750967

raw_data/13.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a7b0409ae480f242e4ce62ca0c6694710459c8df1169dad5f1105adc20050a2
+size 23249464

raw_data/14.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a25e5ef2c908adeb88692e7d306cdb84f6b31b84cf722a66b8a06664e11606b
+size 15485912

raw_data/15.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74cbae286bcd8e9a6209fff2b6ce7d75fe18e478d0731957fdc47d32ad550f34
+size 16017542

raw_data/16.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a0b34fd181c86d6ff4a829f9ccf0a7fcf9f3e901ce07acadfabaf8fe9768617
+size 17147104

raw_data/17.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9caad660878bf5d198abb9020dc770ff26b2134e95a168d08f99018912c8dd3
+size 14880769

raw_data/18.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1f38fc7b9805972f3b67d47781088dea15d20c5b7a9fd39919c2a05248c9258
+size 17188925

raw_data/19.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3e236289285308934ba9800e846dbfc40c8c1e542bfe5329d76a3c2c42c3af2
+size 15952857

raw_data/2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e043d2600ec6d1d918184d3de6f9c848976bd3844418239acd3aac8b760fe958
+size 40525855

raw_data/20.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfab6793d569677ffa3c144bb79edf0592d92fcb5340432d31b4070123d150de
+size 17354868

raw_data/21.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08284c3f5f9ee54132f297be27b1beecf5d7075c20b7ed1547014693236b85c4
+size 15281958

raw_data/22.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1a93e09ff5dc9522df1e1cbf82a79d8a8aefbdd9a7ba164cb83a8511c9508f6
+size 22178602

raw_data/23.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9479a067a829872638999816d15d648f0a6e8117583697a18f18c93bfc4295b9
+size 31585222

raw_data/24.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed963df4a07a99781523da4f36ab8280da5fec51e7d24711f9782e77e1b29d0f
+size 17337513

raw_data/25.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f11e79d3389a1bd71e8a17a87ccd069374bfcf568a01b0bfe2a3f53342a505b9
+size 31150026

raw_data/3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e70a3d6fc974a5037e6c260244dd121a1f4967b369b3779c4d2cd0790abf523e
+size 34635903

raw_data/4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c00d592ff597a2f9b130a6dd577641e6219591cc92adc76d505d831d814ed30
+size 33715353

raw_data/5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdf2661189b8454277cab44e73eadd318dfa32a37b80eaac6ed29dce68aee4a9
+size 38107300

raw_data/6.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41c3faaf5e35e5f2c03ded20b82aa8d19dc4d3bec7114a86bac80906169d98e0
+size 25177537

raw_data/7.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db4eb0237f24d77811eeca3d49469fd6a82f08513a9a525f1d8effc6b9a9241e
+size 21966253

raw_data/8.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:449d59e64c9d82957d39296c4a74b3c675f705f746c20fb971be36cdde79f43a
+size 21020296

raw_data/9.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66dc8ca47e6accddcce08f4ba30515f9b6d46c995e27f4f59210facfad3a5706
+size 27945214

search_r1_corpus.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:741affc0363d4bad7e8871559dd6f849d5b19fd73a99e0124c100974c64255a7
+size 443937190