Add files using upload-large-folder tool

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp 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
+metadata.parquet filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,62 @@
+---
+dataset_info:
+  features:
+  - name: text
+    dtype: string
+  - name: video
+    dtype: string
+  - name: hard_negative_texts
+    list: string
+  - name: hard_negative_videos
+    list: string
+  splits:
+  - name: train
+    num_bytes: 956287081
+    num_examples: 2700
+  download_size: 956287081
+  dataset_size: 956287081
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: metadata.parquet
+---
+
+# Physics Bench Solid With Hard Negatives
+
+Repository: `gowitheflowlab/physics-bench-solid-w-hardnegs`
+
+Source dataset: `gowitheflowlab/physics-bench-solid-train-2700`
+
+This repository follows the path-based layout of `gowitheflowlab/physics-bench-optics-w-hardnegs`.
+
+- rows: 2700
+- metadata columns: `text`, `video`, `hard_negative_texts`, `hard_negative_videos`
+- positive text: query 1 (`__query_1`) from the source case
+- hard negatives per row: 5
+- video paths: repository-relative `videos/<family>/<case_id>.mp4`
+- list alignment: `hard_negative_texts[i]` and `hard_negative_videos[i]` come from the same case
+- candidate pool: only the other 99 cases in the positive case's family
+
+## Reproducibility
+
+- global seed: 42
+- traversal: family alphabetical order, then case_id order
+- sampling: one `random.Random(42)` stream for all 2700 rows
+- selection: `random.sample(sorted(other_99_case_ids), 5)`
+
+## Loading
+
+```python
+from pathlib import Path
+import pyarrow.parquet as pq
+from huggingface_hub import snapshot_download
+
+root = Path(snapshot_download("gowitheflowlab/physics-bench-solid-w-hardnegs", repo_type="dataset"))
+rows = pq.read_table(root / "metadata.parquet").to_pylist()
+row = rows[0]
+positive_video = root / row["video"]
+negative_videos = [root / path for path in row["hard_negative_videos"]]
+```
+
+The training metadata intentionally contains only the four retrieval columns. Case IDs and query IDs are retained in `source_metadata/sampling_manifest.json` for auditing.

generation_manifest.json

@@ -0,0 +1,10 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-solid-w-hardnegs",
+  "source_repo": "gowitheflowlab/physics-bench-solid-train-2700",
+  "seed": 42,
+  "query_suffix": "__query_1",
+  "algorithm": "one random.Random(seed) stream; sorted families; sorted case_id; random.sample(other_99, 5)",
+  "family_count": 27,
+  "total_rows": 2700,
+  "assignment_sha256": "666ca8db70d4b46e9998ae2a99883d5e5796e51a3067845d6adfdef6bf47ea95"
+}

metadata.parquet

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

quality/validation.json

@@ -0,0 +1,58 @@
+{
+  "passed": true,
+  "errors": [],
+  "metadata_rows": 2700,
+  "metadata_columns": [
+    "text",
+    "video",
+    "hard_negative_texts",
+    "hard_negative_videos"
+  ],
+  "video_files": 2700,
+  "missing_videos": [],
+  "hard_negative_pairs": 13500,
+  "cross_family_hard_negatives": 0,
+  "self_hard_negatives": 0,
+  "source_video_sha256": "a109a943cf8996ef2fad61c61f54a4116778d400165fd1fc3208935a77b2dd00",
+  "output_video_sha256": "a109a943cf8996ef2fad61c61f54a4116778d400165fd1fc3208935a77b2dd00",
+  "video_bytes_preserved": true,
+  "repo_id": "gowitheflowlab/physics-bench-solid-w-hardnegs",
+  "source_repo": "gowitheflowlab/physics-bench-solid-train-2700",
+  "seed": 42,
+  "query_suffix": "__query_1",
+  "family_count": 27,
+  "rows_per_family": {
+    "biaxialTension": 100,
+    "bucklingSnapthrough": 100,
+    "cantileverLocalization": 100,
+    "contactPatchCompression": 100,
+    "cubeCompression3D": 100,
+    "cylinderTorsion3D": 100,
+    "hyperelasticNeoHookean3D": 100,
+    "hyperelasticNeoHookeanCuboid3D": 100,
+    "hyperelasticNeoHookeanSphere3D": 100,
+    "loadUnloadHysteresis": 100,
+    "longCuboidBending3D": 100,
+    "nearIncompressibleBlock": 100,
+    "necking": 100,
+    "neoHookean": 100,
+    "notchedBarTension3D": 100,
+    "plasticJ2CylinderTension3D": 100,
+    "plasticJ2LargeStrain3D": 100,
+    "plasticJ2NotchedBar3D": 100,
+    "plateWithHole": 100,
+    "plateWithHole3D": 100,
+    "pureShear": 100,
+    "sphereIndentation3D": 100,
+    "threePointBending": 100,
+    "torsionShear": 100,
+    "uniaxialCompression": 100,
+    "uniaxialTension": 100,
+    "yieldHardening": 100
+  },
+  "assignment_sha256": "666ca8db70d4b46e9998ae2a99883d5e5796e51a3067845d6adfdef6bf47ea95",
+  "second_pass_assignment_sha256": "666ca8db70d4b46e9998ae2a99883d5e5796e51a3067845d6adfdef6bf47ea95",
+  "reproducibility_verified": true,
+  "single_rng_stream": true,
+  "traversal_order": "family alphabetical, then case_id"
+}

source_metadata/build_hf_hardneg_dataset.py

@@ -0,0 +1,549 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import shutil
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+
+NEGATIVE_COUNT = 5
+SOURCE_COLUMNS = ("query_id", "case_id", "raw_text", "parsed_text", "video")
+OUTPUT_COLUMNS = ("text", "video", "hard_negative_texts", "hard_negative_videos")
+
+HF_FEATURES = {
+    "text": {"dtype": "string", "_type": "Value"},
+    "video": {"dtype": "string", "_type": "Value"},
+    "hard_negative_texts": {
+        "feature": {"dtype": "string", "_type": "Value"},
+        "length": -1,
+        "_type": "List",
+    },
+    "hard_negative_videos": {
+        "feature": {"dtype": "string", "_type": "Value"},
+        "length": -1,
+        "_type": "List",
+    },
+}
+
+OUTPUT_SCHEMA = pa.schema(
+    [
+        pa.field("text", pa.string()),
+        pa.field("video", pa.string()),
+        pa.field("hard_negative_texts", pa.list_(pa.string())),
+        pa.field("hard_negative_videos", pa.list_(pa.string())),
+    ],
+    metadata={
+        b"huggingface": json.dumps(
+            {"info": {"features": HF_FEATURES}},
+            separators=(",", ":"),
+        ).encode()
+    },
+)
+
+
+def _write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _source_files(source_dir: Path) -> list[tuple[str, Path]]:
+    return sorted(
+        ((path.parent.name, path) for path in source_dir.glob("*/train-*.parquet")),
+        key=lambda item: item[0],
+    )
+
+
+def _read_query_rows(
+    path: Path,
+    *,
+    query_suffix: str,
+    include_video: bool,
+) -> list[dict[str, Any]]:
+    columns = list(SOURCE_COLUMNS if include_video else SOURCE_COLUMNS[:-1])
+    table = pq.read_table(path, columns=columns)
+    filtered = table.filter(pc.ends_with(table["query_id"], pattern=query_suffix))
+    return sorted(filtered.to_pylist(), key=lambda row: str(row["case_id"]))
+
+
+def _sample_assignments(
+    family_rows: dict[str, list[dict[str, Any]]],
+    *,
+    seed: int,
+) -> dict[str, dict[str, list[str]]]:
+    rng = random.Random(seed)
+    assignments: dict[str, dict[str, list[str]]] = {}
+    for family in sorted(family_rows):
+        rows = sorted(family_rows[family], key=lambda row: str(row["case_id"]))
+        family_assignments: dict[str, list[str]] = {}
+        for row in rows:
+            case_id = str(row["case_id"])
+            candidates = [
+                str(candidate["case_id"])
+                for candidate in rows
+                if str(candidate["case_id"]) != case_id
+            ]
+            family_assignments[case_id] = rng.sample(candidates, NEGATIVE_COUNT)
+        assignments[family] = family_assignments
+    return assignments
+
+
+def _assignment_digest(assignments: dict[str, dict[str, list[str]]]) -> str:
+    payload = [
+        {
+            "family": family,
+            "case_id": case_id,
+            "negative_case_ids": assignments[family][case_id],
+        }
+        for family in sorted(assignments)
+        for case_id in sorted(assignments[family])
+    ]
+    serialized = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(serialized.encode()).hexdigest()
+
+
+def _video_relpath(family: str, case_id: str) -> str:
+    return f"videos/{family}/{case_id}.mp4"
+
+
+def _update_video_digest(digest: Any, relpath: str, data: bytes) -> None:
+    digest.update(relpath.encode())
+    digest.update(b"\0")
+    digest.update(data)
+    digest.update(b"\n")
+
+
+def _readme(
+    *,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    query_suffix: str,
+    total_rows: int,
+    metadata_size: int,
+    video_size: int,
+) -> str:
+    total_size = metadata_size + video_size
+    return "\n".join(
+        [
+            "---",
+            "dataset_info:",
+            "  features:",
+            "  - name: text",
+            "    dtype: string",
+            "  - name: video",
+            "    dtype: string",
+            "  - name: hard_negative_texts",
+            "    list: string",
+            "  - name: hard_negative_videos",
+            "    list: string",
+            "  splits:",
+            "  - name: train",
+            f"    num_bytes: {total_size}",
+            f"    num_examples: {total_rows}",
+            f"  download_size: {total_size}",
+            f"  dataset_size: {total_size}",
+            "configs:",
+            "- config_name: default",
+            "  data_files:",
+            "  - split: train",
+            "    path: metadata.parquet",
+            "---",
+            "",
+            "# Physics Bench Solid With Hard Negatives",
+            "",
+            f"Repository: `{repo_id}`",
+            "",
+            f"Source dataset: `{source_repo}`",
+            "",
+            "This repository follows the path-based layout of "
+            "`gowitheflowlab/physics-bench-optics-w-hardnegs`.",
+            "",
+            f"- rows: {total_rows}",
+            "- metadata columns: `text`, `video`, `hard_negative_texts`, "
+            "`hard_negative_videos`",
+            f"- positive text: query 1 (`{query_suffix}`) from the source case",
+            f"- hard negatives per row: {NEGATIVE_COUNT}",
+            "- video paths: repository-relative `videos/<family>/<case_id>.mp4`",
+            "- list alignment: `hard_negative_texts[i]` and "
+            "`hard_negative_videos[i]` come from the same case",
+            "- candidate pool: only the other 99 cases in the positive case's family",
+            "",
+            "## Reproducibility",
+            "",
+            f"- global seed: {seed}",
+            "- traversal: family alphabetical order, then case_id order",
+            f"- sampling: one `random.Random({seed})` stream for all {total_rows} rows",
+            "- selection: `random.sample(sorted(other_99_case_ids), 5)`",
+            "",
+            "## Loading",
+            "",
+            "```python",
+            "from pathlib import Path",
+            "import pyarrow.parquet as pq",
+            "from huggingface_hub import snapshot_download",
+            "",
+            f'root = Path(snapshot_download("{repo_id}", repo_type="dataset"))',
+            'rows = pq.read_table(root / "metadata.parquet").to_pylist()',
+            "row = rows[0]",
+            'positive_video = root / row["video"]',
+            'negative_videos = [root / path for path in row["hard_negative_videos"]]',
+            "```",
+            "",
+            "The training metadata intentionally contains only the four retrieval "
+            "columns. Case IDs and query IDs are retained in "
+            "`source_metadata/sampling_manifest.json` for auditing.",
+            "",
+        ]
+    )
+
+
+def _validate_output(
+    *,
+    out_dir: Path,
+    metadata_rows: list[dict[str, Any]],
+    family_rows: dict[str, list[dict[str, Any]]],
+    expected_total_rows: int,
+    source_video_hash: str,
+) -> dict[str, Any]:
+    errors: list[str] = []
+    table = pq.read_table(out_dir / "metadata.parquet")
+    if tuple(table.column_names) != OUTPUT_COLUMNS:
+        errors.append(
+            f"metadata columns are {table.column_names}, expected {OUTPUT_COLUMNS}"
+        )
+    written_rows = table.to_pylist()
+    if len(written_rows) != expected_total_rows:
+        errors.append(
+            f"metadata has {len(written_rows)} rows, expected {expected_total_rows}"
+        )
+    if written_rows != metadata_rows:
+        errors.append("metadata changed during parquet serialization")
+
+    source_by_path: dict[str, dict[str, Any]] = {}
+    for family, rows in family_rows.items():
+        for row in rows:
+            relpath = _video_relpath(family, str(row["case_id"]))
+            source_by_path[relpath] = row
+
+    seen_positive_paths: set[str] = set()
+    hard_negative_pairs = 0
+    cross_family_count = 0
+    self_negative_count = 0
+    for row in written_rows:
+        video = str(row["video"])
+        source = source_by_path.get(video)
+        if source is None:
+            errors.append(f"positive video path is unknown: {video}")
+            continue
+        family = Path(video).parts[1]
+        if video in seen_positive_paths:
+            errors.append(f"duplicate positive video path: {video}")
+        seen_positive_paths.add(video)
+        if str(row["text"]) != str(source["raw_text"]):
+            errors.append(f"positive text mismatch: {video}")
+
+        negative_texts = list(row["hard_negative_texts"])
+        negative_videos = [str(path) for path in row["hard_negative_videos"]]
+        if (
+            len(negative_texts) != NEGATIVE_COUNT
+            or len(negative_videos) != NEGATIVE_COUNT
+        ):
+            errors.append(f"{video}: expected five hard negatives")
+        if len(set(negative_videos)) != NEGATIVE_COUNT:
+            errors.append(f"{video}: hard-negative videos are not unique")
+        for negative_text, negative_video in zip(
+            negative_texts,
+            negative_videos,
+        ):
+            hard_negative_pairs += 1
+            negative_source = source_by_path.get(negative_video)
+            if negative_source is None:
+                errors.append(f"{video}: unknown hard-negative path {negative_video}")
+                continue
+            if Path(negative_video).parts[1] != family:
+                cross_family_count += 1
+            if negative_video == video:
+                self_negative_count += 1
+            if str(negative_text) != str(negative_source["raw_text"]):
+                errors.append(
+                    f"{video}: hard-negative text/path mismatch for {negative_video}"
+                )
+
+    if cross_family_count:
+        errors.append(f"found {cross_family_count} cross-family hard negatives")
+    if self_negative_count:
+        errors.append(f"found {self_negative_count} self hard negatives")
+
+    output_digest = hashlib.sha256()
+    missing_videos: list[str] = []
+    for relpath in sorted(source_by_path):
+        path = out_dir / relpath
+        if not path.is_file() or path.stat().st_size == 0:
+            missing_videos.append(relpath)
+            continue
+        _update_video_digest(output_digest, relpath, path.read_bytes())
+    output_video_hash = output_digest.hexdigest()
+    if output_video_hash != source_video_hash:
+        errors.append("video bytes changed while creating the hard-negative dataset")
+
+    return {
+        "passed": not errors,
+        "errors": errors[:100],
+        "metadata_rows": len(written_rows),
+        "metadata_columns": table.column_names,
+        "video_files": len(source_by_path) - len(missing_videos),
+        "missing_videos": missing_videos[:100],
+        "hard_negative_pairs": hard_negative_pairs,
+        "cross_family_hard_negatives": cross_family_count,
+        "self_hard_negatives": self_negative_count,
+        "source_video_sha256": source_video_hash,
+        "output_video_sha256": output_video_hash,
+        "video_bytes_preserved": source_video_hash == output_video_hash,
+    }
+
+
+def build_dataset(
+    *,
+    source_dir: Path,
+    out_dir: Path,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    query_suffix: str,
+    expected_rows_per_family: int,
+    expected_total_rows: int,
+) -> dict[str, Any]:
+    source_files = _source_files(source_dir)
+    if not source_files:
+        raise FileNotFoundError(
+            f"No source family parquet files found under {source_dir}"
+        )
+
+    family_rows = {
+        family: _read_query_rows(
+            path,
+            query_suffix=query_suffix,
+            include_video=False,
+        )
+        for family, path in source_files
+    }
+    bad_counts = {
+        family: len(rows)
+        for family, rows in family_rows.items()
+        if len(rows) != expected_rows_per_family
+    }
+    if bad_counts:
+        raise ValueError(
+            f"Expected {expected_rows_per_family} query-1 rows per family: {bad_counts}"
+        )
+    if sum(map(len, family_rows.values())) != expected_total_rows:
+        raise ValueError(f"Expected {expected_total_rows} query-1 rows in total")
+    for family, rows in family_rows.items():
+        case_ids = [str(row["case_id"]) for row in rows]
+        if len(case_ids) != len(set(case_ids)):
+            raise ValueError(f"Duplicate query-1 case IDs in family {family}")
+
+    assignments = _sample_assignments(family_rows, seed=seed)
+    repeated = _sample_assignments(family_rows, seed=seed)
+    if assignments != repeated:
+        raise AssertionError("Hard-negative sampling is not reproducible")
+
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    out_dir.mkdir(parents=True)
+
+    metadata_rows: list[dict[str, Any]] = []
+    manifest_rows: list[dict[str, Any]] = []
+    source_video_digest = hashlib.sha256()
+    video_size = 0
+    source_file_map = dict(source_files)
+    for family in sorted(family_rows):
+        rows = family_rows[family]
+        by_case = {str(row["case_id"]): row for row in rows}
+        rows_with_video = _read_query_rows(
+            source_file_map[family],
+            query_suffix=query_suffix,
+            include_video=True,
+        )
+        video_by_case = {
+            str(row["case_id"]): row["video"] for row in rows_with_video
+        }
+        if set(video_by_case) != set(by_case):
+            raise ValueError(f"Query/video case mismatch in family {family}")
+
+        for source_row in rows:
+            case_id = str(source_row["case_id"])
+            query_id = str(source_row["query_id"])
+            if not query_id.endswith(query_suffix):
+                raise ValueError(f"Unexpected query ID for query 1: {query_id}")
+
+            relpath = _video_relpath(family, case_id)
+            video_value = video_by_case[case_id]
+            video_bytes = bytes(video_value["bytes"])
+            if not video_bytes:
+                raise ValueError(f"Empty source video bytes for {case_id}")
+            video_path = out_dir / relpath
+            video_path.parent.mkdir(parents=True, exist_ok=True)
+            video_path.write_bytes(video_bytes)
+            video_size += len(video_bytes)
+            _update_video_digest(source_video_digest, relpath, video_bytes)
+
+            negative_case_ids = assignments[family][case_id]
+            negative_rows = [by_case[negative_id] for negative_id in negative_case_ids]
+            negative_paths = [
+                _video_relpath(family, negative_id)
+                for negative_id in negative_case_ids
+            ]
+            metadata_rows.append(
+                {
+                    "text": str(source_row["raw_text"]),
+                    "video": relpath,
+                    "hard_negative_texts": [
+                        str(row["raw_text"]) for row in negative_rows
+                    ],
+                    "hard_negative_videos": negative_paths,
+                }
+            )
+            manifest_rows.append(
+                {
+                    "family": family,
+                    "case_id": case_id,
+                    "query_id": query_id,
+                    "video": relpath,
+                    "negative_case_ids": negative_case_ids,
+                    "negative_query_ids": [
+                        str(row["query_id"]) for row in negative_rows
+                    ],
+                    "hard_negative_videos": negative_paths,
+                }
+            )
+
+        del rows_with_video
+        del video_by_case
+
+    metadata_path = out_dir / "metadata.parquet"
+    table = pa.Table.from_pylist(metadata_rows, schema=OUTPUT_SCHEMA)
+    pq.write_table(
+        table,
+        metadata_path,
+        compression="snappy",
+        row_group_size=100,
+        write_page_index=True,
+    )
+    source_video_hash = source_video_digest.hexdigest()
+    validation = _validate_output(
+        out_dir=out_dir,
+        metadata_rows=metadata_rows,
+        family_rows=family_rows,
+        expected_total_rows=expected_total_rows,
+        source_video_hash=source_video_hash,
+    )
+    assignment_hash = _assignment_digest(assignments)
+    validation.update(
+        {
+            "repo_id": repo_id,
+            "source_repo": source_repo,
+            "seed": seed,
+            "query_suffix": query_suffix,
+            "family_count": len(family_rows),
+            "rows_per_family": {
+                family: len(rows) for family, rows in family_rows.items()
+            },
+            "assignment_sha256": assignment_hash,
+            "second_pass_assignment_sha256": _assignment_digest(repeated),
+            "reproducibility_verified": assignments == repeated,
+            "single_rng_stream": True,
+            "traversal_order": "family alphabetical, then case_id",
+        }
+    )
+    _write_json(out_dir / "quality" / "validation.json", validation)
+    _write_json(
+        out_dir / "generation_manifest.json",
+        {
+            "repo_id": repo_id,
+            "source_repo": source_repo,
+            "seed": seed,
+            "query_suffix": query_suffix,
+            "algorithm": (
+                "one random.Random(seed) stream; sorted families; sorted case_id; "
+                "random.sample(other_99, 5)"
+            ),
+            "family_count": len(family_rows),
+            "total_rows": len(metadata_rows),
+            "assignment_sha256": assignment_hash,
+        },
+    )
+    _write_json(
+        out_dir / "source_metadata" / "sampling_manifest.json",
+        manifest_rows,
+    )
+    shutil.copy2(
+        Path(__file__).resolve(),
+        out_dir / "source_metadata" / Path(__file__).name,
+    )
+    (out_dir / ".gitattributes").write_text(
+        "*.mp4 filter=lfs diff=lfs merge=lfs -text\n",
+        encoding="utf-8",
+    )
+    (out_dir / "README.md").write_text(
+        _readme(
+            repo_id=repo_id,
+            source_repo=source_repo,
+            seed=seed,
+            query_suffix=query_suffix,
+            total_rows=len(metadata_rows),
+            metadata_size=metadata_path.stat().st_size,
+            video_size=video_size,
+        ),
+        encoding="utf-8",
+    )
+    if not validation["passed"]:
+        raise ValueError(f"Validation failed: {validation['errors'][:10]}")
+    return validation
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build a path-based solid hard-negative video dataset."
+    )
+    parser.add_argument("--source-dir", type=Path, required=True)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument(
+        "--repo-id",
+        default="gowitheflowlab/physics-bench-solid-w-hardnegs",
+    )
+    parser.add_argument(
+        "--source-repo",
+        default="gowitheflowlab/physics-bench-solid-train-2700",
+    )
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--query-suffix", default="__query_1")
+    parser.add_argument("--expected-rows-per-family", type=int, default=100)
+    parser.add_argument("--expected-total-rows", type=int, default=2700)
+    args = parser.parse_args()
+    result = build_dataset(
+        source_dir=args.source_dir.resolve(),
+        out_dir=args.out_dir.resolve(),
+        repo_id=args.repo_id,
+        source_repo=args.source_repo,
+        seed=args.seed,
+        query_suffix=args.query_suffix,
+        expected_rows_per_family=args.expected_rows_per_family,
+        expected_total_rows=args.expected_total_rows,
+    )
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

videos/uniaxialTension/uniaxialTension_S000.mp4

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

videos/uniaxialTension/uniaxialTension_S001.mp4

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

videos/uniaxialTension/uniaxialTension_S005.mp4

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

videos/uniaxialTension/uniaxialTension_S007.mp4

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

videos/uniaxialTension/uniaxialTension_S009.mp4

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

videos/uniaxialTension/uniaxialTension_S010.mp4

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

videos/uniaxialTension/uniaxialTension_S011.mp4

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

videos/uniaxialTension/uniaxialTension_S015.mp4

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

videos/uniaxialTension/uniaxialTension_S017.mp4

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

videos/uniaxialTension/uniaxialTension_S025.mp4

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

videos/uniaxialTension/uniaxialTension_S026.mp4

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

videos/uniaxialTension/uniaxialTension_S027.mp4

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

videos/uniaxialTension/uniaxialTension_S034.mp4

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

videos/uniaxialTension/uniaxialTension_S036.mp4

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

videos/uniaxialTension/uniaxialTension_S040.mp4

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

videos/uniaxialTension/uniaxialTension_S043.mp4

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

videos/uniaxialTension/uniaxialTension_S045.mp4

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

videos/uniaxialTension/uniaxialTension_S046.mp4

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

videos/uniaxialTension/uniaxialTension_S047.mp4

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

videos/uniaxialTension/uniaxialTension_S048.mp4

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

videos/uniaxialTension/uniaxialTension_S049.mp4

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

videos/uniaxialTension/uniaxialTension_S050.mp4

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

videos/uniaxialTension/uniaxialTension_S053.mp4

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

videos/uniaxialTension/uniaxialTension_S054.mp4

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

videos/uniaxialTension/uniaxialTension_S056.mp4

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

videos/uniaxialTension/uniaxialTension_S058.mp4

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

videos/uniaxialTension/uniaxialTension_S059.mp4

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

videos/uniaxialTension/uniaxialTension_S063.mp4

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

videos/uniaxialTension/uniaxialTension_S067.mp4

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

videos/uniaxialTension/uniaxialTension_S068.mp4

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

videos/uniaxialTension/uniaxialTension_S069.mp4

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

videos/uniaxialTension/uniaxialTension_S071.mp4

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

videos/uniaxialTension/uniaxialTension_S075.mp4

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

videos/uniaxialTension/uniaxialTension_S078.mp4

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

videos/uniaxialTension/uniaxialTension_S085.mp4

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

videos/uniaxialTension/uniaxialTension_S086.mp4

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

videos/uniaxialTension/uniaxialTension_S091.mp4

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

videos/uniaxialTension/uniaxialTension_S098.mp4

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

videos/uniaxialTension/uniaxialTension_S099.mp4

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

videos/uniaxialTension/uniaxialTension_S103.mp4

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

videos/uniaxialTension/uniaxialTension_S105.mp4

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

videos/uniaxialTension/uniaxialTension_S106.mp4

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

videos/uniaxialTension/uniaxialTension_S111.mp4

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