Datasets:

zeyuzy
/

DLLM-Planing-Task


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)