Add audited non-additive Cipher-17 5M/5k dataset

cipher17_nonadditive_5m/README.md

@@ -0,0 +1,21 @@
+# Cipher-17 Non-Additive 5M/5k
+
+This package contains the harder non-additive member of the anchored Cipher-17 family.
+
+- Vocabulary: decimal digits 0-9
+- Sequence rule: n=17, k=5, c0=p0, ci=fi(pi,p(i+5 mod 17))
+- Each position-specific fi is a fixed 10x10 Latin square stored in meta.pkl
+- train.bin: 5,000,000 rows
+- test.bin: 5,000 rows
+- Row layout: 34 uint16 values, [17 ciphertext digits][17 plaintext digits]
+- block_size: 34; vocab_size: 11
+
+The first 1,000 test rows are byte-identical to the original generated test set. The remaining 4,000 rows use seed 42 and were checked to be unique and disjoint from the 5M training plaintexts. All 5,000 rows were exactly decoded with the saved maps.
+
+SHA256:
+
+- train.bin: cb6cd210dfc3266dc3c3ca16c813c8101bb076c56430c753425f409f2a26ed45
+- test.bin: b7d8eceb88624c05c4d25e37d722875af8f2ef22a129c2a703735800ec0a0918
+- meta.pkl: dbce00b19e96653338b3f32a8c30ee9df0a099a06e46bc2c17b7442d4050e9fe
+
+See test5k_audit.json and the provenance files for the full checks and source versions.

cipher17_nonadditive_5m/build_cipher17_nonadditive_test5k.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""Expand the fixed non-additive Cipher-17 test set from 1k to 5k.
+
+The first 1,000 rows are preserved exactly.  Four thousand deterministic rows
+are generated with the saved Latin-square maps in ``meta.pkl`` and seed 42.
+New plaintexts are required to be absent from both the 5M training set and the
+preserved 1k test prefix.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import pickle
+import random
+from pathlib import Path
+
+import numpy as np
+
+
+N = 17
+K_OFFSET = 5
+BLOCK_SIZE = 34
+DTYPE = np.dtype(np.uint16)
+POWERS_10 = np.asarray([10**power for power in range(N - 1, -1, -1)], dtype=np.uint64)
+SOLVE_ORDER = [12, 7, 2, 14, 9, 4, 16, 11, 6, 1, 13, 8, 3, 15, 10, 5]
+
+
+def sha256_file(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(chunk_size):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def row_count(path: Path) -> int:
+    row_bytes = BLOCK_SIZE * DTYPE.itemsize
+    size = path.stat().st_size
+    if size % row_bytes:
+        raise ValueError(f"{path} size {size} is not divisible by row size {row_bytes}")
+    return size // row_bytes
+
+
+def encode_plain_rows(rows: np.ndarray) -> np.ndarray:
+    plain = np.asarray(rows[:, N:BLOCK_SIZE], dtype=np.uint64)
+    return np.sum(plain * POWERS_10, axis=1, dtype=np.uint64)
+
+
+def plain_key(plain: list[int]) -> int:
+    key = 0
+    for digit in plain:
+        key = key * 10 + digit
+    return key
+
+
+def validate_latin_maps(functions: list[list[list[int]]]) -> None:
+    if len(functions) != N:
+        raise ValueError(f"expected {N} functions, got {len(functions)}")
+    target = list(range(10))
+    for index, table in enumerate(functions):
+        arr = np.asarray(table)
+        if arr.shape != (10, 10):
+            raise ValueError(f"function {index} has shape {arr.shape}, expected (10, 10)")
+        if any(sorted(row.tolist()) != target for row in arr):
+            raise ValueError(f"function {index} has a non-permutation row")
+        if any(sorted(arr[:, column].tolist()) != target for column in range(10)):
+            raise ValueError(f"function {index} has a non-permutation column")
+
+
+def build_train_key_index(train: np.memmap, chunk_rows: int = 100_000) -> np.ndarray:
+    keys = np.empty(len(train), dtype=np.uint64)
+    for start in range(0, len(train), chunk_rows):
+        stop = min(start + chunk_rows, len(train))
+        keys[start:stop] = encode_plain_rows(train[start:stop])
+    keys.sort()
+    return keys
+
+
+def key_in_sorted(sorted_keys: np.ndarray, key: int) -> bool:
+    index = int(np.searchsorted(sorted_keys, np.uint64(key), side="left"))
+    return index < len(sorted_keys) and int(sorted_keys[index]) == key
+
+
+def encode_cipher(plain: list[int], functions: list[list[list[int]]]) -> list[int]:
+    cipher = [0] * N
+    cipher[0] = plain[0]
+    for index in range(1, N):
+        dependency = (index + K_OFFSET) % N
+        cipher[index] = int(functions[index][plain[index]][plain[dependency]])
+    return cipher
+
+
+def verify_rows(rows: np.ndarray, functions: list[list[list[int]]]) -> None:
+    for row_index, row in enumerate(rows):
+        cipher = [int(value) for value in row[:N]]
+        truth = [int(value) for value in row[N:BLOCK_SIZE]]
+        solved = [-1] * N
+        solved[0] = cipher[0]
+        for index in SOLVE_ORDER:
+            dependency = (index + K_OFFSET) % N
+            candidates = [
+                value
+                for value in range(10)
+                if functions[index][value][solved[dependency]] == cipher[index]
+            ]
+            if len(candidates) != 1:
+                raise ValueError(
+                    f"row {row_index}, index {index}: expected one inverse, got {candidates}"
+                )
+            solved[index] = candidates[0]
+        if solved != truth:
+            raise ValueError(f"row {row_index}: decoded plaintext does not match target")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-dir", type=Path, required=True)
+    parser.add_argument("--source-test", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--audit", type=Path, required=True)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--target-rows", type=int, default=5_000)
+    args = parser.parse_args()
+
+    data_dir = args.data_dir.resolve()
+    train_path = data_dir / "train.bin"
+    meta_path = data_dir / "meta.pkl"
+    source_test_path = args.source_test.resolve()
+    output_path = args.output.resolve()
+    audit_path = args.audit.resolve()
+
+    for required in (train_path, meta_path, source_test_path):
+        if not required.is_file():
+            raise FileNotFoundError(required)
+
+    train_rows = row_count(train_path)
+    source_rows = row_count(source_test_path)
+    if train_rows != 5_000_000:
+        raise ValueError(f"expected 5,000,000 train rows, got {train_rows}")
+    if source_rows != 1_000:
+        raise ValueError(f"expected 1,000 preserved test rows, got {source_rows}")
+    if args.target_rows < source_rows:
+        raise ValueError("target rows cannot be smaller than preserved source rows")
+
+    with meta_path.open("rb") as handle:
+        meta = pickle.load(handle)
+    if meta.get("block_size") != BLOCK_SIZE:
+        raise ValueError(f"unexpected block_size: {meta.get('block_size')}")
+    functions = meta["functions"]
+    validate_latin_maps(functions)
+
+    train = np.memmap(
+        train_path, dtype=DTYPE, mode="r", shape=(train_rows, BLOCK_SIZE)
+    )
+    source_test = np.memmap(
+        source_test_path, dtype=DTYPE, mode="r", shape=(source_rows, BLOCK_SIZE)
+    )
+    train_keys = build_train_key_index(train)
+    source_keys_array = encode_plain_rows(source_test)
+    source_keys = {int(key) for key in source_keys_array}
+    if len(source_keys) != source_rows:
+        raise ValueError("preserved 1k test contains duplicate plaintext rows")
+    train_overlap = sum(key_in_sorted(train_keys, key) for key in source_keys)
+    if train_overlap:
+        raise ValueError(f"preserved test overlaps train in {train_overlap} rows")
+
+    rng = random.Random(args.seed)
+    needed = args.target_rows - source_rows
+    generated_rows: list[list[int]] = []
+    rejected_train = 0
+    rejected_test = 0
+    while len(generated_rows) < needed:
+        plain = [rng.randrange(10) for _ in range(N)]
+        key = plain_key(plain)
+        if key in source_keys:
+            rejected_test += 1
+            continue
+        if key_in_sorted(train_keys, key):
+            rejected_train += 1
+            continue
+        source_keys.add(key)
+        generated_rows.append(encode_cipher(plain, functions) + plain)
+
+    combined = np.empty((args.target_rows, BLOCK_SIZE), dtype=DTYPE)
+    combined[:source_rows] = source_test
+    combined[source_rows:] = np.asarray(generated_rows, dtype=DTYPE)
+    verify_rows(combined, functions)
+    combined.tofile(output_path)
+
+    expected_bytes = args.target_rows * BLOCK_SIZE * DTYPE.itemsize
+    if output_path.stat().st_size != expected_bytes:
+        raise ValueError(
+            f"output size {output_path.stat().st_size} != expected {expected_bytes}"
+        )
+
+    audit = {
+        "task": "cipher17_nonadditive_test5k_expansion",
+        "n": N,
+        "k_offset": K_OFFSET,
+        "block_size": BLOCK_SIZE,
+        "dtype": "uint16",
+        "seed": args.seed,
+        "train_rows": train_rows,
+        "source_test_rows": source_rows,
+        "added_test_rows": needed,
+        "output_test_rows": args.target_rows,
+        "source_prefix_preserved": bool(
+            np.array_equal(combined[:source_rows], source_test)
+        ),
+        "train_overlap_rows": 0,
+        "test_duplicate_rows": 0,
+        "rejected_train_candidates": rejected_train,
+        "rejected_test_candidates": rejected_test,
+        "latin_maps_validated": len(functions),
+        "decoded_rows_validated": args.target_rows,
+        "train_sha256": sha256_file(train_path),
+        "source_test_sha256": sha256_file(source_test_path),
+        "meta_sha256": sha256_file(meta_path),
+        "output_test_sha256": sha256_file(output_path),
+        "output_test_bytes": output_path.stat().st_size,
+    }
+    audit_path.write_text(json.dumps(audit, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(audit, indent=2))
+
+
+if __name__ == "__main__":
+    main()

cipher17_nonadditive_5m/create_data.py

@@ -0,0 +1,265 @@
+
+import json
+import random
+import numpy
+import pickle
+
+n = 17  # 长度改为 13
+k_offset = 5  # 步长 (与 13 互质)
+num_train = 5000000
+num_test = 1000
+
+# 一个固定的、按位置变化的常量，扩展到 13 位
+# (来自圆周率，只是为了固定且看起来随机)
+pos_const = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2] # 扩展了一位
+
+
+
+import random
+from typing import List, Tuple, Set, Optional
+
+Latin = List[List[int]]
+
+def cyclic_latin_square(n: int = 10) -> Latin:
+    return [[(i + j) % n for j in range(n)] for i in range(n)]
+
+def is_latin_square(L: Latin) -> bool:
+    n = len(L)
+    target = set(range(n))
+    for i in range(n):
+        if set(L[i]) != target:
+            return False
+    for j in range(n):
+        col = {L[i][j] for i in range(n)}
+        if col != target:
+            return False
+    return True
+
+def _try_random_intercalate_move(L: Latin, rng: random.Random) -> bool:
+    """
+    Try one random 2x2 intercalate flip. Return True if moved, else False.
+    """
+    n = len(L)
+    r1, r2 = rng.sample(range(n), 2)
+    c1, c2 = rng.sample(range(n), 2)
+
+    a = L[r1][c1]
+    b = L[r1][c2]
+    if a == b:
+        return False
+
+    # Need the 2x2 pattern:
+    # L[r1,c1]=a, L[r1,c2]=b
+    # L[r2,c1]=b, L[r2,c2]=a
+    if L[r2][c1] != b or L[r2][c2] != a:
+        return False
+
+    # Flip to:
+    # b a
+    # a b
+    L[r1][c1], L[r1][c2] = b, a
+    L[r2][c1], L[r2][c2] = a, b
+    return True
+
+def mcmc_step(L: Latin, rng: random.Random, lazy_p: float = 0.1, max_trials: int = 200) -> None:
+    """
+    One Markov step:
+      - with probability lazy_p: do nothing (aperiodicity)
+      - else: attempt up to max_trials random intercalate moves; if none found, do nothing
+    """
+    if rng.random() < lazy_p:
+        return
+    for _ in range(max_trials):
+        if _try_random_intercalate_move(L, rng):
+            return
+    # No valid move found in trials -> stay
+
+def sample_latin_square_10(
+    rng: random.Random,
+    burn_in: int = 50_000,
+    steps_after: int = 20_000,
+    lazy_p: float = 0.1,
+    max_trials_per_step: int = 200
+) -> Latin:
+    """
+    Start from cyclic Latin square and run MCMC.
+    Return one approximately-uniform sample.
+    """
+    L = cyclic_latin_square(10)
+
+    # Burn-in
+    for _ in range(burn_in):
+        mcmc_step(L, rng, lazy_p=lazy_p, max_trials=max_trials_per_step)
+
+    # Extra steps (thinning / further mixing)
+    for _ in range(steps_after):
+        mcmc_step(L, rng, lazy_p=lazy_p, max_trials=max_trials_per_step)
+
+    return [row[:] for row in L]
+
+def make_functions(
+    n: int,
+    seed: Optional[int] = None,
+    burn_in: int = 500000,
+    steps_between_samples: int = 500000,
+    lazy_p: float = 0.1,
+    max_trials_per_step: int = 200
+) -> List[Latin]:
+    """
+    Generate n distinct 10x10 Latin squares via MCMC (approx uniform).
+    Distinctness is enforced by hashing full matrices.
+    """
+    rng = random.Random(seed)
+    out: List[Latin] = []
+    seen: Set[Tuple[Tuple[int, ...], ...]] = set()
+
+    # We keep one chain running and take samples separated by steps_between_samples.
+    L = cyclic_latin_square(10)
+
+    # burn-in on the running chain
+    for _ in range(burn_in):
+        mcmc_step(L, rng, lazy_p=lazy_p, max_trials=max_trials_per_step)
+
+    while len(out) < n:
+        # advance chain
+        for _ in range(steps_between_samples):
+            mcmc_step(L, rng, lazy_p=lazy_p, max_trials=max_trials_per_step)
+
+        sample = [row[:] for row in L]
+        key = tuple(tuple(row) for row in sample)
+        if key in seen:
+            continue
+        # Safety check (can be removed for speed)
+        if not is_latin_square(sample):
+            raise RuntimeError("Internal error: produced a non-Latin square (should not happen).")
+
+        seen.add(key)
+        out.append(sample)
+
+    return out
+
+functions = make_functions(n=n)
+
+print(functions)
+
+#print(xxx)
+
+def generate_samples_anchored_global(num_samples):
+    samples = []
+    
+    vocab = '0123456789'
+    for _ in range(num_samples):
+        # 1. 随机明文 (数字列表)
+        plain_digits = [random.randint(0, 9) for _ in range(n)]
+        
+        cipher_digits = [0] * n
+        
+        # 2. 设置“锚点”
+        # cipher[0] = plain[0]
+        cipher_digits[0] = plain_digits[0]
+        
+        # 3. 生成全局依赖
+        for i in range(1, n):
+            # cipher[i] = (plain[i] + plain[(i + k) % n] + C[i]) % 10
+            j = (i + k_offset) % n
+            val = functions[i][plain_digits[i]][plain_digits[j]]
+            #(plain_digits[i] + plain_digits[j] + pos_const[i]) % 10
+            cipher_digits[i] = val
+
+            
+        # 转换回字符串
+        #plain_str = ''.join(map(str, plain_digits))
+        #cipher_str = ''.join(map(str, cipher_digits))
+        
+        #samples.append({"input": cipher_str, "output": plain_str})
+        samples.append(cipher_digits+plain_digits)
+        #test_samples.append(cipher_digits+plain_digits)
+        
+    return numpy.array(samples,dtype=numpy.uint16)
+
+# --- 生成文件 ---
+train_samples = generate_samples_anchored_global(num_train)
+
+print(train_samples[0])
+#print(xxx)
+train_samples.tofile('train.bin')
+
+
+#with open(f'{n}_anchored_global_mod10_train.jsonl', 'w') as f:
+#    for s in train_samples:
+#        f.write(json.dumps(s) + '\n')
+
+test_samples = generate_samples_anchored_global(num_test)
+test_samples.tofile('test.bin')
+#with open(f'{n}_anchored_global_mod10_test.jsonl', 'w') as f:
+#    for s in test_samples:
+#        f.write(json.dumps(s) + '\n')
+
+print(f"Generated {num_train} train samples and {num_test} test samples for ANCHORED GLOBAL (mod 10) task.")
+print(f"n={n}, k_offset={k_offset}")
+
+meta = {
+    'vocab_size': 11,
+    'block_size': n * 2, 
+    'functions': functions
+}
+with open('meta.pkl', 'wb') as f:
+    pickle.dump(meta, f)
+
+
+
+# --- 验证逻辑 ---
+# 打印一个样本的解密过程，用于验证
+print("\n--- Verification Sample ---")
+if test_samples is None:
+    print("No test samples generated for verification.")
+else:
+
+    for t in range(len(test_samples)):
+        c_str = test_samples[0,0:n]
+        p_str = test_samples[0,n:2*n]
+        #print(f"Cipher: {c_str}")
+        #print(f"Plain:  {p_str}")
+
+        # 手动验证解密链
+        c = [int(x) for x in c_str]
+        p_actual = [int(x) for x in p_str]
+        p_solved = [-1] * n # -1 表示未知
+
+        #print("\nSolving sequence (MDM's perspective):")
+        p_solved[0] = c[0]
+        #print(f"Step 0: Solved p[0] = c[0] = {p_solved[0]}")
+
+        # (n=13, k=5) 的求解顺序
+        # 求解 p[i] 需要 p[(i+k)%n]
+        # 反过来看，p[0] -> p[i] s.t. (i+5)%13 = 0 => i = 8
+        # p[8] -> p[i] s.t. (i+5)%13 = 8 => i = 3
+        # p[3] -> p[i] s.t. (i+5)%13 = 3 => i = -2 % 13 = 11
+        # 链条: 0 -> 8 -> 3 -> 11 -> 6 -> 1 -> 9 -> 4 -> 12 -> 7 -> 2 -> 10 -> 5
+        solve_order = [12, 7, 2, 14, 9, 4, 16, 11, 6, 1, 13, 8, 3, 15, 10, 5]
+        
+        for i_solve in solve_order:
+            # 找到它依赖谁
+            i_depend_on = (i_solve + k_offset) % n
+            # plain[i] = (cipher[i] - plain[j] - C[i]) % 10
+            val = -1
+            for j in range(10):
+                if functions[i_solve][j][p_solved[i_depend_on]] == c[i_solve]:
+                    val = j
+                    break
+            if(val == -1):
+                print("Oh no, what happens!")
+            
+            #(c[i_solve] - p_solved[i_depend_on] - pos_const[i_solve]) % 10
+            p_solved[i_solve] = val
+            #print(f"Step N: Solved p[{i_solve}] = (c[{i_solve}] - p[{i_depend_on}] - C[{i_solve}]) % 10 = {val}")
+
+        #print("\nSolved Plain:", numpy.array(p_solved))
+        #print("Actual Plain:", p_str)
+        
+        if (p_str == numpy.array(p_solved)).all():
+            #print("Verification SUCCESSFUL.")
+            continue
+        else:
+            print("Verification FAILED.")
+            print(xxxxx)

cipher17_nonadditive_5m/create_data_provenance.txt

@@ -0,0 +1,34 @@
+task=cipher17_nonadditive_create_data
+task_type=cpu_only
+status=starting
+machine=DESKTOP-KB6AIKM
+run_id=20260811_165314
+source_script=/e/code/Kits/Projects/self-evolving-trajectories-private/create_data.py
+source_sha256=a5dfa24cf9f4d970a0fa7b2658fb666e74168c2619f7b461a9195b93a2332ea7
+branch=codex/serfox-compile-stability-20260726
+commit=c87090214afac547d6f7e42212bbe2f4ac876506
+git_dirty=dirty
+python_bin=python
+python_args=-S
+pythonpath=/d/code/anaconda/Lib/site-packages
+python_version=Python 3.9.13
+output_dir=/f/Dataset/DLLM_dataset
+log_path=/f/Dataset/DLLM_dataset/create_data_cipher17_nonadditive_20260811_165314.log
+run_command_original=cd "/f/Dataset/DLLM_dataset" && PYTHONPATH="/d/code/anaconda/Lib/site-packages" "python" -S "/e/code/Kits/Projects/self-evolving-trajectories-private/create_data.py"
+config_n=17
+config_k_offset=5
+config_num_train=5000000
+config_num_test=1000
+config_dtype=uint16
+expected_train_bytes=340000000
+expected_test_bytes=68000
+status=completed
+generator_exit_code=0
+train_path=/f/Dataset/DLLM_dataset/train.bin
+test_path=/f/Dataset/DLLM_dataset/test.bin
+meta_path=/f/Dataset/DLLM_dataset/meta.pkl
+train_bytes=340000000
+test_bytes=68000
+train_sha256=cb6cd210dfc3266dc3c3ca16c813c8101bb076c56430c753425f409f2a26ed45
+test_sha256=756281dfc7b0fb8178287ced37ea247c85ede409970da01a43417ff2497a33fa
+meta_sha256=dbce00b19e96653338b3f32a8c30ee9df0a099a06e46bc2c17b7442d4050e9fe

cipher17_nonadditive_5m/meta.pkl

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

cipher17_nonadditive_5m/publish_launcher.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+DATA_DIR="${DLLM_DATASET_DIR:-/f/Dataset/DLLM_dataset}"
+HF_REPO_ID="${HF_REPO_ID:-zeyuzy/DLLM-Planing-Task}"
+HF_REPO_PREFIX="${HF_REPO_PREFIX:-cipher17_nonadditive_5m}"
+PYTHON_BIN="${PYTHON_BIN:-python}"
+PYTHONPATH_EXTRA="/d/code/anaconda/Lib/site-packages"
+export PYTHONPATH="$PYTHONPATH_EXTRA${PYTHONPATH:+:$PYTHONPATH}"
+PYTHON_ARGS=(-S)
+
+TRAIN_PATH="$DATA_DIR/train.bin"
+TEST_PATH="$DATA_DIR/test.bin"
+META_PATH="$DATA_DIR/meta.pkl"
+TEST1K_BACKUP="$DATA_DIR/test1k_original.bin"
+TEST5K_TMP="$DATA_DIR/test5k.bin.tmp"
+AUDIT_PATH="$DATA_DIR/cipher17_nonadditive_test5k_audit.json"
+AUDIT_TMP="$DATA_DIR/cipher17_nonadditive_test5k_audit.json.tmp"
+README_PATH="$DATA_DIR/cipher17_nonadditive_5m_README.md"
+PROV_PATH="$DATA_DIR/cipher17_nonadditive_test5k_provenance.txt"
+RUN_ID="$(date +%Y%m%d_%H%M%S)"
+LOG_PATH="$DATA_DIR/cipher17_nonadditive_test5k_hf_${RUN_ID}.log"
+
+EXPECTED_TRAIN_SHA="cb6cd210dfc3266dc3c3ca16c813c8101bb076c56430c753425f409f2a26ed45"
+EXPECTED_META_SHA="dbce00b19e96653338b3f32a8c30ee9df0a099a06e46bc2c17b7442d4050e9fe"
+EXPECTED_TEST1K_SHA="756281dfc7b0fb8178287ced37ea247c85ede409970da01a43417ff2497a33fa"
+
+die() {
+  printf 'ERROR: %s\n' "$*" >&2
+  exit 1
+}
+
+sha_of() {
+  sha256sum "$1" | awk '{print $1}'
+}
+
+[[ -f "$TRAIN_PATH" ]] || die "missing $TRAIN_PATH"
+[[ -f "$TEST_PATH" ]] || die "missing $TEST_PATH"
+[[ -f "$META_PATH" ]] || die "missing $META_PATH"
+[[ "$(sha_of "$TRAIN_PATH")" == "$EXPECTED_TRAIN_SHA" ]] || die "train hash drift"
+[[ "$(sha_of "$META_PATH")" == "$EXPECTED_META_SHA" ]] || die "meta hash drift"
+
+CURRENT_TEST_BYTES="$(stat -c%s "$TEST_PATH")"
+if [[ "$CURRENT_TEST_BYTES" == "68000" ]]; then
+  [[ "$(sha_of "$TEST_PATH")" == "$EXPECTED_TEST1K_SHA" ]] || die "source test1k hash drift"
+  if [[ -e "$TEST1K_BACKUP" ]]; then
+    [[ "$(sha_of "$TEST1K_BACKUP")" == "$EXPECTED_TEST1K_SHA" ]] || die "existing test1k backup hash drift"
+  else
+    cp -p "$TEST_PATH" "$TEST1K_BACKUP"
+  fi
+  rm -f "$TEST5K_TMP" "$AUDIT_TMP"
+  "$PYTHON_BIN" "${PYTHON_ARGS[@]}" \
+    "$REPO_ROOT/data/build_cipher17_nonadditive_test5k.py" \
+    --data-dir "$DATA_DIR" \
+    --source-test "$TEST1K_BACKUP" \
+    --output "$TEST5K_TMP" \
+    --audit "$AUDIT_TMP" \
+    --seed 42 \
+    --target-rows 5000
+  [[ "$(stat -c%s "$TEST5K_TMP")" == "340000" ]] || die "generated test5k size mismatch"
+  mv "$TEST5K_TMP" "$TEST_PATH"
+  mv "$AUDIT_TMP" "$AUDIT_PATH"
+elif [[ "$CURRENT_TEST_BYTES" == "340000" ]]; then
+  [[ -f "$TEST1K_BACKUP" ]] || die "test is already 5k but preserved test1k backup is missing"
+  [[ -f "$AUDIT_PATH" ]] || die "test is already 5k but audit is missing"
+  [[ "$(sha_of "$TEST1K_BACKUP")" == "$EXPECTED_TEST1K_SHA" ]] || die "test1k backup hash drift"
+else
+  die "unexpected test.bin size: $CURRENT_TEST_BYTES"
+fi
+
+TEST5K_SHA="$(sha_of "$TEST_PATH")"
+BRANCH="$(git -C "$REPO_ROOT" branch --show-current)"
+COMMIT="$(git -C "$REPO_ROOT" rev-parse HEAD)"
+SOURCE_SHA="$(sha_of "$REPO_ROOT/create_data.py")"
+BUILDER_SHA="$(sha_of "$REPO_ROOT/data/build_cipher17_nonadditive_test5k.py")"
+
+cat > "$README_PATH" <<EOF
+# Cipher-17 Non-Additive 5M/5k
+
+This package contains the harder non-additive member of the anchored Cipher-17 family.
+
+- Vocabulary: decimal digits 0-9
+- Sequence rule: n=17, k=5, c0=p0, ci=fi(pi,p(i+5 mod 17))
+- Each position-specific fi is a fixed 10x10 Latin square stored in meta.pkl
+- train.bin: 5,000,000 rows
+- test.bin: 5,000 rows
+- Row layout: 34 uint16 values, [17 ciphertext digits][17 plaintext digits]
+- block_size: 34; vocab_size: 11
+
+The first 1,000 test rows are byte-identical to the original generated test set. The remaining 4,000 rows use seed 42 and were checked to be unique and disjoint from the 5M training plaintexts. All 5,000 rows were exactly decoded with the saved maps.
+
+SHA256:
+
+- train.bin: $EXPECTED_TRAIN_SHA
+- test.bin: $TEST5K_SHA
+- meta.pkl: $EXPECTED_META_SHA
+
+See test5k_audit.json and the provenance files for the full checks and source versions.
+EOF
+
+cat > "$PROV_PATH" <<EOF
+task=cipher17_nonadditive_test5k_and_hf_publish
+task_type=cpu_only_external_upload
+status=prepared
+machine=$(hostname)
+run_id=$RUN_ID
+branch=$BRANCH
+commit=$COMMIT
+git_dirty=$(git -C "$REPO_ROOT" status --porcelain | wc -l)
+data_dir=$DATA_DIR
+hf_repo_id=$HF_REPO_ID
+hf_repo_prefix=$HF_REPO_PREFIX
+source_script=$REPO_ROOT/create_data.py
+source_sha256=$SOURCE_SHA
+builder_script=$REPO_ROOT/data/build_cipher17_nonadditive_test5k.py
+builder_sha256=$BUILDER_SHA
+train_sha256=$EXPECTED_TRAIN_SHA
+test1k_backup_sha256=$EXPECTED_TEST1K_SHA
+test5k_sha256=$TEST5K_SHA
+meta_sha256=$EXPECTED_META_SHA
+test5k_rows=5000
+test5k_bytes=$(stat -c%s "$TEST_PATH")
+audit_path=$AUDIT_PATH
+log_path=$LOG_PATH
+EOF
+
+set +e
+"$PYTHON_BIN" "${PYTHON_ARGS[@]}" \
+  "$REPO_ROOT/scripts/experiments/upload_cipher17_nonadditive_hf.py" \
+  --repo-id "$HF_REPO_ID" \
+  --repo-prefix "$HF_REPO_PREFIX" \
+  --data-dir "$DATA_DIR" \
+  --repo-root "$REPO_ROOT" \
+  2>&1 | tee "$LOG_PATH"
+UPLOAD_STATUS=${PIPESTATUS[0]}
+set -e
+
+if [[ "$UPLOAD_STATUS" -ne 0 ]]; then
+  {
+    printf 'status=upload_failed\n'
+    printf 'upload_exit_code=%s\n' "$UPLOAD_STATUS"
+  } >> "$PROV_PATH"
+  exit "$UPLOAD_STATUS"
+fi
+
+COMMIT_OID="$(grep -m1 '"commit_oid"' "$LOG_PATH" | sed -E 's/.*"commit_oid": "([^"]+)".*/\1/')"
+COMMIT_URL="$(grep -m1 '"commit_url"' "$LOG_PATH" | sed -E 's/.*"commit_url": "([^"]+)".*/\1/')"
+{
+  printf 'status=completed\n'
+  printf 'upload_exit_code=0\n'
+  printf 'hf_commit_oid=%s\n' "$COMMIT_OID"
+  printf 'hf_commit_url=%s\n' "$COMMIT_URL"
+} >> "$PROV_PATH"
+
+printf 'Prepared test5k and uploaded HF package successfully.\n'

cipher17_nonadditive_5m/test.bin

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

cipher17_nonadditive_5m/test5k_audit.json

@@ -0,0 +1,24 @@
+{
+  "task": "cipher17_nonadditive_test5k_expansion",
+  "n": 17,
+  "k_offset": 5,
+  "block_size": 34,
+  "dtype": "uint16",
+  "seed": 42,
+  "train_rows": 5000000,
+  "source_test_rows": 1000,
+  "added_test_rows": 4000,
+  "output_test_rows": 5000,
+  "source_prefix_preserved": true,
+  "train_overlap_rows": 0,
+  "test_duplicate_rows": 0,
+  "rejected_train_candidates": 0,
+  "rejected_test_candidates": 0,
+  "latin_maps_validated": 17,
+  "decoded_rows_validated": 5000,
+  "train_sha256": "cb6cd210dfc3266dc3c3ca16c813c8101bb076c56430c753425f409f2a26ed45",
+  "source_test_sha256": "756281dfc7b0fb8178287ced37ea247c85ede409970da01a43417ff2497a33fa",
+  "meta_sha256": "dbce00b19e96653338b3f32a8c30ee9df0a099a06e46bc2c17b7442d4050e9fe",
+  "output_test_sha256": "b7d8eceb88624c05c4d25e37d722875af8f2ef22a129c2a703735800ec0a0918",
+  "output_test_bytes": 340000
+}

cipher17_nonadditive_5m/test5k_provenance.txt

@@ -0,0 +1,23 @@
+task=cipher17_nonadditive_test5k_and_hf_publish
+task_type=cpu_only_external_upload
+status=prepared
+machine=DESKTOP-KB6AIKM
+run_id=20260811_192947
+branch=codex/serfox-compile-stability-20260726
+commit=c8aa0ff3887b2e6a575971c5f288d2afc812f111
+git_dirty=98
+data_dir=/f/Dataset/DLLM_dataset
+hf_repo_id=zeyuzy/DLLM-Planing-Task
+hf_repo_prefix=cipher17_nonadditive_5m
+source_script=/e/code/Kits/Projects/self-evolving-trajectories-private/create_data.py
+source_sha256=a5dfa24cf9f4d970a0fa7b2658fb666e74168c2619f7b461a9195b93a2332ea7
+builder_script=/e/code/Kits/Projects/self-evolving-trajectories-private/data/build_cipher17_nonadditive_test5k.py
+builder_sha256=e23f1bb889611c3fc3dccea7cca5dcd9a5fc1011fe48067d68d698057c9fd2db
+train_sha256=cb6cd210dfc3266dc3c3ca16c813c8101bb076c56430c753425f409f2a26ed45
+test1k_backup_sha256=756281dfc7b0fb8178287ced37ea247c85ede409970da01a43417ff2497a33fa
+test5k_sha256=b7d8eceb88624c05c4d25e37d722875af8f2ef22a129c2a703735800ec0a0918
+meta_sha256=dbce00b19e96653338b3f32a8c30ee9df0a099a06e46bc2c17b7442d4050e9fe
+test5k_rows=5000
+test5k_bytes=340000
+audit_path=/f/Dataset/DLLM_dataset/cipher17_nonadditive_test5k_audit.json
+log_path=/f/Dataset/DLLM_dataset/cipher17_nonadditive_test5k_hf_20260811_192947.log

cipher17_nonadditive_5m/train.bin

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