موقعیتِ نسبی در RoPE با پایتون؛ چرخشِ Q/K و خطای فشرده‌کردنِ فاصله‌ها

وقتی چند توکنِ قدیمی را برای ادامهٔ یک مکالمه نگه می‌داریم، شمارهٔ خانهٔ ذخیره و موقعیتِ اصلیِ توکن الزاماً یکسان نیستند. در محاسبه‌ای که موقعیت را واردِ امتیاز می‌کند، جمع‌کردنِ فاصله‌های خالی می‌تواند خودِ عدد را عوض کند. این درس با بردارهای ساختگی و کسرهای دقیق، همین تفاوت را باز می‌کند؛ نه مدلِ زبانی اجرا می‌شود، نه کشِ واقعی و نه آزمایشِ کیفیتِ پاسخ.

۱. شناسهٔ موقعیت با خانهٔ بافر یکی نیست

در پنجرهٔ جفت‌های کاملِ مکالمه، مسئله سالم‌ماندنِ پرسش و پاسخ زیر بودجهٔ نقاط کد بود. آن سیاست دربارهٔ نگهداریِ متن تصمیم می‌گرفت. اینجا متن و توکن‌ساز نداریم: یک بردارِ پرسش Q، چند بردارِ کلید K و شناسه‌های موقعیت را از پیش می‌دهیم. کلیدهای باقی‌مانده ممکن است در خانه‌های صفر و یکِ یک سینی باشند، ولی به موقعیت‌های اصلیِ یک و سه تعلق داشته باشند.

مؤلفه‌ها ویژگی‌های بی‌بعدند و شناسهٔ موقعیت، عددِ ترتیبیِ قراردادی است؛ میلی‌ثانیه، بایت یا تعدادِ نقطهٔ کد نیست. عرضِ بردار دقیقاً دو یا چهار، هر مؤلفه دقیقاً int از منفیِ دو تا مثبتِ دو و تعدادِ کلیدها از صفر تا چهار است. موقعیت‌ها int از صفر تا هشت‌اند؛ موقعیتِ کلیدها باید صعودیِ اکید و با بردارها هم‌ردیف باشد. bool، زیرکلاس و تبدیلِ ضمنی پذیرفته نمی‌شوند.

در هستهٔ توجهِ علّی، ضرب داخلی پس از مقیاس‌گذاری واردِ softmax و ترکیبِ V می‌شد. این مثال تنها امتیازِ خامِ ضربِ داخلی را برمی‌گرداند. ماسک و V ندارد؛ حتی اگر موقعیتِ کلیدی از پرسش جلوتر باشد، پذیرشِ عددیِ آن مجوزِ توجهِ علّی محسوب نمی‌شود.

۲. دو مؤلفه را با یک چرخشِ مشخص همراه کنیم

بخشِ سومِ مقالهٔ RoFormer، موقعیت را با چرخاندنِ جفت‌های ویژگی واردِ Q و K می‌کند. قراردادِ ما بردارِ ستونی و جفت‌های مجاورِ (x₀,x₁) و (x₂,x₃) است. برای یک گام، ماتریسِ R برابرِ [[c,−s],[s,c]] است؛ در موقعیتِ p، همان چرخش p بار اعمال می‌شود. پس جفتِ (x,y) در یک گام به (cx−sy,sx+cy) می‌رود.

برای دوری از خطای تقریبِ sin و cos، c و s را به‌صورتِ Fraction تألیفی می‌دهیم و دقیقاً c²+s²=1 می‌خواهیم؛ مثلاً 3/5 و 4/5. قدرمطلقِ صورت و مخرجِ هر جزء حداکثر سیزده است. این جدول، فرکانس‌های مدلِ آموزش‌دیده یا تنظیمِ پیش‌فرضِ Transformers نیست. برای هر جفت، یک چرخشِ ثابت و یکسان در Q و K به کار می‌رود.

اگر q در موقعیتِ m و k در n باشد، امتیاز برابر است با (Rᵐq)ᵀ(Rⁿk)=qᵀRⁿ⁻ᵐk. ترانهادهٔ چرخش، وارونِ آن است؛ بنابراین علامتِ اختلاف در این قرارداد n−m است. با q=(1,0)، k=(0,1)، m=0 و n=1، کلیدِ چرخیده (−4/5,3/5) و امتیاز −4/5 است. با جابه‌جاییِ دو موقعیت، جواب +4/5 می‌شود؛ تغییرِ علامتِ s، خطایی بی‌اثر نیست.

چرخشِ واحد، مربعِ اندازهٔ هر بردار را حفظ می‌کند، اما ضربِ داخلیِ دو بردار در موقعیت‌های متفاوت الزاماً ثابت نیست. همچنین چیدمانِ split-half ذاتاً نادرست نیست؛ اگر ترتیبِ مؤلفه‌ها و نگاشتِ فرکانس‌ها هماهنگ عوض شوند، نمایشِ دیگری از همان محاسبه می‌سازد. خطای شاهدِ ما، جابه‌جاییِ مؤلفه‌ها و باقی‌گذاشتنِ قاعدهٔ جفت‌بندیِ قبلی است.

۳. جابه‌جاییِ مشترک، فاصله‌ها را حفظ می‌کند

افزودنِ یک عددِ یکسان به m و همهٔ nها، اختلاف‌ها را تغییر نمی‌دهد؛ با Q و K ثابت، امتیازها نیز ثابت می‌مانند. در رابطِ محدود باید موقعیت‌های تازه همچنان در صفر تا هشت بمانند. این خاصیت با شماره‌گذاریِ فشردهٔ دلخواه فرق دارد: حذفِ شکاف‌ها می‌تواند برای هر کلید، اختلافِ دیگری بسازد.

شاهدِ اصلی q=(1,0) در موقعیتِ چهار و دو کلیدِ یکسانِ (1,0) در موقعیت‌های یک و سه است. با چرخشِ 3/5 و 4/5، امتیازها −117/125 و 3/5 هستند. اگر موقعیت‌ها را به پرسشِ دو و کلیدهای صفر و یک فشرده کنیم، جوابِ اول −7/25 می‌شود و دومی 3/5 می‌ماند. اختلاف‌های قبلی منفیِ سه و منفیِ یک بودند؛ اکنون منفیِ دو و منفیِ یک‌اند. این تغییر، خطای گردکردن نیست.

در مقابل، کم‌کردنِ یک از همهٔ موقعیت‌های شاهد، پرسشِ سه و کلیدهای صفر و دو می‌دهد و هر دو امتیاز را حفظ می‌کند. ترتیبِ بردارهای کلید هم مهم است: تغییرِ ترتیبِ K بدونِ نگه‌داشتنِ هم‌ردیفیِ شناسه‌ها، ورودیِ دیگری می‌سازد. تابع برای مرتب‌سازی، موقعیت‌ها را از بردارها جدا نمی‌کند.

این برابری دربارهٔ ویژگی‌های ثابت است. اگر مدل را دوباره روی متنِ کوتاه‌شده اجرا کنیم، خودِ Q و K ممکن است تغییر کنند. برنامه نیز کلیدِ ازپیش‌چرخیدهٔ یک کش را نمی‌گیرد و با برچسبِ تازه دوباره نمی‌چرخاند. حفظِ اندازه، تضمینِ افتِ یکنوای امتیاز با فاصله هم نیست؛ چرخش دوره‌ای است و یک امتیاز می‌تواند دوباره افزایش یابد.

۴. کدِ کسری و مرجعِ مستقلِ بسطِ دوجمله‌ای

مسیرِ اصلی، توانِ ماتریسِ دو در دو را با ضرب‌های محدود می‌سازد، Q و K را می‌چرخاند و مؤلفه‌ها را ضرب و جمع می‌کند. همهٔ ورودی‌ها پیش از اولین چرخش اعتبارسنجی می‌شوند؛ خطای آخرین کلید، محاسبهٔ بخشی از یک درخواستِ نامعتبر را آغاز نمی‌کند. کلیدِ تهی با فهرستِ موقعیتِ تهی، خروجیِ تهی می‌دهد، ولی پرسش و چرخش‌ها همچنان باید معتبر باشند.

مرجع، این حلقهٔ ماتریسی را تکرار نمی‌کند. برای هر جفت، (c+is) را با بسطِ دوجمله‌ای به توانِ قدرمطلقِ n−m می‌رساند؛ بخش‌های حقیقی و موهومی از توان‌های i جدا می‌شوند. برای اختلافِ منفی، مزدوج می‌گیرد. سپس صورتِ بازشدهٔ ضرب داخلی، c′(xu+yv)+s′(yu−xv)، جواب را مستقل از بردارهای چرخیده می‌سازد. مقایسه دقیقِ کسری است و تلورانس یا epsilon ندارد.

"""Finite supplied rotary-position geometry; no model or cache is executed."""
from fractions import Fraction
from itertools import product
from math import comb
import json
import platform
import sys

MAX_POSITION = 8
MAX_KEYS = 4
MAX_COMPONENT = 2
MAX_ROTATION_PART = 13


def _tuple(value, name):
    if type(value) is not tuple:
        raise TypeError(name + ' must be an exact tuple')


def _vector(value, width=None):
    _tuple(value, 'vector')
    if len(value) not in (2, 4) or (width is not None and len(value) != width):
        raise ValueError('vector width must be 2 or 4 and match the query')
    for x in value:
        if type(x) is not int:
            raise TypeError('components must be exact integers, excluding bool')
        if abs(x) > MAX_COMPONENT:
            raise ValueError('component outside [-2,2]')


def _position(value):
    if type(value) is not int:
        raise TypeError('positions must be exact integers, excluding bool')
    if not 0 <= value <= MAX_POSITION:
        raise ValueError('position outside 0..8')


def _contract(query, keys, query_position, key_positions, rotations):
    _vector(query)
    _tuple(keys, 'keys')
    _tuple(key_positions, 'key positions')
    _tuple(rotations, 'rotations')
    if len(keys) > MAX_KEYS or len(key_positions) != len(keys):
        raise ValueError('up to four aligned key vectors and positions required')
    _position(query_position)
    if len(rotations) != len(query) // 2:
        raise ValueError('one rotation per adjacent feature pair required')
    for rotor in rotations:
        _tuple(rotor, 'rotation')
        if len(rotor) != 2:
            raise ValueError('each rotation is a (cosine,sine) pair')
        for part in rotor:
            if type(part) is not Fraction:
                raise TypeError('rotation parts must be exact Fractions')
            if (abs(part.numerator) > MAX_ROTATION_PART
                    or part.denominator > MAX_ROTATION_PART):
                raise ValueError('rotation numerator/denominator cap exceeded')
        c, s = rotor
        if c*c + s*s != 1:
            raise ValueError('rotation must lie exactly on the unit circle')
    for key, position in zip(keys, key_positions):
        _vector(key, len(query))
        _position(position)
    if any(a >= b for a, b in zip(key_positions, key_positions[1:])):
        raise ValueError('key position IDs must be strictly increasing')


def _mm2(a, b):
    return tuple(tuple(sum((a[i][t] * b[t][j] for t in range(2)), Fraction(0))
                       for j in range(2)) for i in range(2))


def _power2(c, s, position):
    result = ((Fraction(1), Fraction(0)), (Fraction(0), Fraction(1)))
    base = ((c, -s), (s, c))
    for _ in range(position):
        result = _mm2(result, base)
    return result


def _rotate_validated(vector, position, rotations):
    values = []
    for pair_index, (c, s) in enumerate(rotations):
        matrix = _power2(c, s, position)
        x, y = vector[2*pair_index:2*pair_index+2]
        values.extend((matrix[0][0]*x + matrix[0][1]*y,
                       matrix[1][0]*x + matrix[1][1]*y))
    return tuple(values)


def rotary_scores(query, keys, query_position, key_positions, rotations):
    """Return exact raw dots; supplied features and explicit IDs, no softmax."""
    _contract(query, keys, query_position, key_positions, rotations)
    rotated_query = _rotate_validated(query, query_position, rotations)
    answer = []
    for key, position in zip(keys, key_positions):
        rotated_key = _rotate_validated(key, position, rotations)
        answer.append(sum((a*b for a, b in zip(rotated_query, rotated_key)),
                          Fraction(0)))
    return tuple(answer)


def binomial_oracle(query, keys, query_position, key_positions, rotations):
    """Valid fixtures only. Relative complex-polynomial expansion, no matrices."""
    answers = []
    for key_number in range(len(keys)):
        relative = key_positions[key_number] - query_position
        exponent = abs(relative)
        total = Fraction(0)
        for pair_number in range(len(rotations)):
            cosine, sine = rotations[pair_number]
            real, imaginary = Fraction(0), Fraction(0)
            for sine_count in range(exponent + 1):
                term = (comb(exponent, sine_count)
                        * cosine**(exponent-sine_count) * sine**sine_count)
                phase = sine_count % 4
                if phase == 0:
                    real += term
                elif phase == 1:
                    imaginary += term
                elif phase == 2:
                    real -= term
                else:
                    imaginary -= term
            if relative < 0:
                imaginary = -imaginary  # Unit-circle inverse is conjugation.
            x, y = query[2*pair_number:2*pair_number+2]
            u, v = keys[key_number][2*pair_number:2*pair_number+2]
            total += real*(x*u+y*v) + imaginary*(y*u-x*v)
        answers.append(total)
    return tuple(answers)


def _raises(call, expected):
    try:
        call()
    except expected:
        return True
    return False


def run_example():
    f = Fraction
    rotor = ((f(3, 5), f(4, 5)),)
    query, orthogonal_key = (1, 0), (0, 1)
    manual = rotary_scores(query, (orthogonal_key,), 0, (1,), rotor)
    checks = {}
    checks['literal_column_rotation_and_negative_four_fifths_score'] = (
        manual == (f(-4, 5),))
    reverse = rotary_scores(query, (orthogonal_key,), 1, (0,), rotor)
    checks['relative_n_minus_m_sign_changes_when_positions_reverse'] = (
        reverse == (f(4, 5),) and manual != reverse)

    identity = ((f(1), f(0)), (f(1), f(0)))
    q4, k4 = (2, -1, 0, 1), (-1, 2, 1, 0)
    zero = rotary_scores(q4, (k4,), 0, (0,), rotor*2)
    checks['zero_position_and_identity_rotation_preserve_literal_dot'] = (
        zero == (f(-4),)
        and rotary_scores(q4, (k4,), 8, (3,), identity) == zero)

    norm_ok = True
    norm_rotors = (rotor[0], (f(5, 13), f(12, 13)))
    for position in range(9):
        rotated = _rotate_validated(q4, position, norm_rotors)
        norm_ok &= sum(x*x for x in rotated) == sum(x*x for x in q4)
    checks['orthogonal_pair_rotations_preserve_squared_norm'] = bool(norm_ok)
    same_position = tuple(rotary_scores(q4, (k4,), p, (p,), norm_rotors)[0]
                          for p in range(9))
    checks['equal_query_key_position_preserves_unrotated_dot'] = (
        same_position == (f(-4),)*9)

    keys, positions = ((1, 0), (0, 1)), (1, 3)
    base = rotary_scores(query, keys, 4, positions, rotor)
    shift_ok = all(rotary_scores(query, keys, 4+d,
                                tuple(p+d for p in positions), rotor) == base
                   for d in (-1, 0, 1, 2, 3, 4))
    checks['common_valid_translation_preserves_all_relative_scores'] = bool(shift_ok)

    equal_keys = ((1, 0), (1, 0))
    original = rotary_scores(query, equal_keys, 4, (1, 3), rotor)
    compacted = rotary_scores(query, equal_keys, 2, (0, 1), rotor)
    checks['nonuniform_gap_compaction_changes_exact_score'] = (
        original == (f(-117, 125), f(3, 5))
        and compacted == (f(-7, 25), f(3, 5)) and original != compacted)

    aligned = rotary_scores(query, keys, 2, (0, 1), rotor)
    misaligned = rotary_scores(query, tuple(reversed(keys)), 2, (0, 1), rotor)
    checks['explicit_key_ids_must_remain_aligned_with_key_features'] = (
        aligned == (f(-7, 25), f(4, 5))
        and misaligned == (f(24, 25), f(3, 5)) and aligned != misaligned)

    layout_q, layout_k = (1, 2, -1, 0), (0, 1, 2, -1)
    layout_rotors = (rotor[0], (f(0), f(1)))
    adjacent = rotary_scores(layout_q, (layout_k,), 0, (1,), layout_rotors)
    permutation = (0, 2, 1, 3)
    wrong_layout = rotary_scores(tuple(layout_q[i] for i in permutation),
                                (tuple(layout_k[i] for i in permutation),),
                                0, (1,), layout_rotors)
    checks['two_pair_frequencies_require_consistent_pairing_convention'] = (
        adjacent == (f(-3, 5),) and wrong_layout == (f(-4, 5),)
        and adjacent != wrong_layout)

    # ONE finite family: matrix rotation versus direct relative binomial sums.
    family_ok, family_profiles, family_scores = True, 0, 0
    rotors = (rotor[0], (f(5, 13), f(12, 13)), (f(0), f(1)))
    vectors2 = tuple(product((-1, 0, 1), repeat=2))
    for q, k, r, m, n in product(vectors2, vectors2, rotors, range(4), range(4)):
        actual = rotary_scores(q, (k,), m, (n,), (r,))
        family_ok &= actual == binomial_oracle(q, (k,), m, (n,), (r,))
        family_profiles += 1
        family_scores += len(actual)
    for a, b, rs, m, n in product(range(3), range(3), product(rotors, repeat=2),
                                 range(3), range(3)):
        q = tuple((a+2*i) % 3-1 for i in range(4))
        k = tuple((2*b+i) % 3-1 for i in range(4))
        actual = rotary_scores(q, (k,), m, (n,), rs)
        family_ok &= actual == binomial_oracle(q, (k,), m, (n,), rs)
        family_profiles += 1
        family_scores += len(actual)
    checks['independent_relative_binomial_finite_family_ONE_group'] = bool(
        family_ok and family_profiles == family_scores == 4617)

    class IntChild(int):
        pass
    class TupleChild(tuple):
        pass
    class FractionChild(Fraction):
        pass
    valid = (query, ((1, 0),), 1, (0,), rotor)
    invalid = [
        (([1, 0], valid[1], 1, (0,), rotor), TypeError),
        ((TupleChild(query), valid[1], 1, (0,), rotor), TypeError),
        (((True, 0), valid[1], 1, (0,), rotor), TypeError),
        (((IntChild(1), 0), valid[1], 1, (0,), rotor), TypeError),
        (((1.0, 0), valid[1], 1, (0,), rotor), TypeError),
        (((f(1), 0), valid[1], 1, (0,), rotor), TypeError),
        ((query, list(valid[1]), 1, (0,), rotor), TypeError),
        ((query, ([1, 0],), 1, (0,), rotor), TypeError),
        ((query, ((1, 0, 0, 0),), 1, (0,), rotor), ValueError),
        ((query, valid[1], True, (0,), rotor), TypeError),
        ((query, valid[1], IntChild(1), (0,), rotor), TypeError),
        ((query, valid[1], 1, [0], rotor), TypeError),
        ((query, valid[1], 1, (False,), rotor), TypeError),
        ((query, valid[1]*2, 1, (0, 0), rotor), ValueError),
        ((query, valid[1]*2, 1, (2, 1), rotor), ValueError),
        ((query, valid[1], 1, (0,), list(rotor)), TypeError),
        ((query, valid[1], 1, (0,), ([f(3, 5), f(4, 5)],)), TypeError),
        ((query, valid[1], 1, (0,), ((1, 0),)), TypeError),
        ((query, valid[1], 1, (0,), ((FractionChild(1), f(0)),)), TypeError),
        ((query, valid[1], 1, (0,), ((f(3, 5), f(3, 5)),)), ValueError),
        ((query, valid[1], 1, (0,), ((f(1),),)), ValueError),
        ((query, valid[1], 1, (0,), ()), ValueError),
        (((), (), 0, (), ()), ValueError),
        (((1, 0, 1), (), 0, (), rotor), ValueError),
    ]
    checks['strict_types_shapes_unit_circle_and_order_rejections_ONE_group'] = all(
        _raises(lambda args=args: rotary_scores(*args), error)
        for args, error in invalid)

    caps = [((3, 0), valid[1], 1, (0,), rotor),
            (query, valid[1], 9, (0,), rotor),
            (query, valid[1], -1, (0,), rotor),
            (query, valid[1], 1, (9,), rotor),
            (query, valid[1]*5, 8, (0, 1, 2, 3, 4), rotor),
            (query, valid[1], 1, (0,), ((f(14, 15), f(0)),))]
    maximum = rotary_scores((2, -2, 2, -2),
                            ((2, 2, -2, -2), (-2, 2, 2, -2),
                             (2, -2, -2, 2), (-2, -2, 2, 2)),
                            8, (0, 2, 4, 8), norm_rotors)
    generated = []
    def not_consumed():
        generated.append('consumed')
        yield (1, 0)
    rotation_calls = []
    original_rotate = globals()['_rotate_validated']
    def observed_rotate(*args):
        rotation_calls.append(1)
        return original_rotate(*args)
    try:
        globals()['_rotate_validated'] = observed_rotate
        late_rejected = _raises(lambda: rotary_scores(
            query, ((1, 0), (False, 1)), 2, (0, 1), rotor), TypeError)
    finally:
        globals()['_rotate_validated'] = original_rotate
    generator_rejected = _raises(lambda: rotary_scores(
        query, not_consumed(), 1, (0,), rotor), TypeError)
    checks['caps_maximum_profile_complete_prevalidation_and_no_generator_consumption'] = (
        all(_raises(lambda args=args: rotary_scores(*args), ValueError) for args in caps)
        and len(maximum) == 4 and all(type(x) is Fraction for x in maximum)
        and late_rejected and rotation_calls == [] and generator_rejected
        and generated == [])

    checks['empty_keys_require_aligned_positions_and_valid_query_contract'] = (
        rotary_scores(query, (), 0, (), rotor) == ()
        and rotary_scores(q4, (), 8, (), norm_rotors) == ()
        and _raises(lambda: rotary_scores(query, (), 0, (0,), rotor), ValueError)
        and _raises(lambda: rotary_scores((True, 0), (), 0, (), rotor), TypeError))
    before = repr((query, keys, positions, rotor))
    first = rotary_scores(query, keys, 4, positions, rotor)
    second = rotary_scores(query, keys, 4, positions, rotor)
    def attempted_mutation():
        first[0] = f(99)
    checks['fresh_immutable_results_no_input_alias_or_retained_state'] = (
        type(first) is tuple and all(type(x) is Fraction for x in first)
        and first == second and first is not second
        and _raises(attempted_mutation, TypeError)
        and repr((query, keys, positions, rotor)) == before
        and rotary_scores(query, keys, 4, positions, rotor) == first)

    assert len(checks) == 14 and all(type(v) is bool and v for v in checks.values()), checks
    return {'python_version': platform.python_version(),
            'implementation': platform.python_implementation(),
            'dependencies': 'Python standard library only; no model/framework executed',
            'profile': {'width': '2 or 4; adjacent feature pairs',
                        'component_values': 'exact ints [-2,2], unitless',
                        'keys': '0..4, aligned strictly increasing position IDs',
                        'position_IDs': 'exact ints0..8, not storage slots or time',
                        'rotations': 'exact Fraction unit-circle pairs; part caps13',
                        'score': 'raw dot product, not a probability',
                        'column_rotation': '[[c,-s],[s,c]]',
                        'relative_exponent': 'key_position-query_position'},
            'manual_single_pair': {'query': query, 'key': orthogonal_key,
                                   'rotation': rotor[0], 'positions': (0, 1),
                                   'raw_score': manual, 'reverse_score': reverse},
            'gap_compaction': {'query_position': 4, 'key_positions': (1, 3),
                               'original_scores': original,
                               'compacted_query_position': 2,
                               'compacted_key_positions': (0, 1),
                               'compacted_scores': compacted},
            'layout_fixture': {'adjacent_score': adjacent,
                               'permuted_features_with_unadjusted_pair_rule': wrong_layout},
            'family_profiles_inside_ONE_group': family_profiles,
            'family_raw_scores_inside_ONE_group': family_scores,
            'invalid_profiles_inside_ONE_group': len(invalid),
            'resource_rejections_inside_cap_group': len(caps),
            'maximum_profile_scores': maximum,
            'unique_check_groups': len(checks), 'checks': checks,
            'limitations': ['Rational supplied rotation schedule, not actual HF frequencies.',
                            'Fixed Q/K only; rerunning a model can change their contents.',
                            'No real KV cache, tokenizer, training, audio or quality result.',
                            'A common rotation preserves a dot; unequal positions need not.',
                            'No monotonic score decay, context extension or speed guarantee.',
                            'Other pair layouts can be valid with consistent conventions.']}


def _jsonable(value):
    if type(value) is Fraction:
        return str(value)
    if isinstance(value, dict):
        return {key: _jsonable(child) for key, child in value.items()}
    if isinstance(value, (tuple, list)):
        return [_jsonable(child) for child in value]
    return value


if __name__ == '__main__':
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    print(json.dumps(_jsonable(run_example()), ensure_ascii=True,
                     indent=2, allow_nan=False))

خروجیِ کامل، نسخهٔ اجرای واقعی و چهارده گروهِ معنایی را ثبت می‌کند. خانوادهٔ محدودِ مقایسه با مرجع یک گروه است؛ شمارِ پروفایل‌ها و امتیازهای درونی به تعدادِ گروه‌ها افزوده نمی‌شود. شاهدهای دستی، انتقالِ مشترک، فشرده‌سازی، چیدمان، اندازه، ورودیِ مردود، سقف‌ها و خروجیِ تغییرناپذیر هدف‌های جدا دارند. هیچ کتابخانهٔ مدل یا محاسبهٔ وابسته به GPU اجرا نشده است.

{
  "python_version": "3.14.5",
  "implementation": "CPython",
  "dependencies": "Python standard library only; no model/framework executed",
  "profile": {
    "width": "2 or 4; adjacent feature pairs",
    "component_values": "exact ints [-2,2], unitless",
    "keys": "0..4, aligned strictly increasing position IDs",
    "position_IDs": "exact ints0..8, not storage slots or time",
    "rotations": "exact Fraction unit-circle pairs; part caps13",
    "score": "raw dot product, not a probability",
    "column_rotation": "[[c,-s],[s,c]]",
    "relative_exponent": "key_position-query_position"
  },
  "manual_single_pair": {
    "query": [
      1,
      0
    ],
    "key": [
      0,
      1
    ],
    "rotation": [
      "3/5",
      "4/5"
    ],
    "positions": [
      0,
      1
    ],
    "raw_score": [
      "-4/5"
    ],
    "reverse_score": [
      "4/5"
    ]
  },
  "gap_compaction": {
    "query_position": 4,
    "key_positions": [
      1,
      3
    ],
    "original_scores": [
      "-117/125",
      "3/5"
    ],
    "compacted_query_position": 2,
    "compacted_key_positions": [
      0,
      1
    ],
    "compacted_scores": [
      "-7/25",
      "3/5"
    ]
  },
  "layout_fixture": {
    "adjacent_score": [
      "-3/5"
    ],
    "permuted_features_with_unadjusted_pair_rule": [
      "-4/5"
    ]
  },
  "family_profiles_inside_ONE_group": 4617,
  "family_raw_scores_inside_ONE_group": 4617,
  "invalid_profiles_inside_ONE_group": 24,
  "resource_rejections_inside_cap_group": 6,
  "maximum_profile_scores": [
    "2268427623662592/318644812890625",
    "-21880764416/75418890625",
    "-119218176/17850625",
    "0"
  ],
  "unique_check_groups": 14,
  "checks": {
    "literal_column_rotation_and_negative_four_fifths_score": true,
    "relative_n_minus_m_sign_changes_when_positions_reverse": true,
    "zero_position_and_identity_rotation_preserve_literal_dot": true,
    "orthogonal_pair_rotations_preserve_squared_norm": true,
    "equal_query_key_position_preserves_unrotated_dot": true,
    "common_valid_translation_preserves_all_relative_scores": true,
    "nonuniform_gap_compaction_changes_exact_score": true,
    "explicit_key_ids_must_remain_aligned_with_key_features": true,
    "two_pair_frequencies_require_consistent_pairing_convention": true,
    "independent_relative_binomial_finite_family_ONE_group": true,
    "strict_types_shapes_unit_circle_and_order_rejections_ONE_group": true,
    "caps_maximum_profile_complete_prevalidation_and_no_generator_consumption": true,
    "empty_keys_require_aligned_positions_and_valid_query_contract": true,
    "fresh_immutable_results_no_input_alias_or_retained_state": true
  },
  "limitations": [
    "Rational supplied rotation schedule, not actual HF frequencies.",
    "Fixed Q/K only; rerunning a model can change their contents.",
    "No real KV cache, tokenizer, training, audio or quality result.",
    "A common rotation preserves a dot; unequal positions need not.",
    "No monotonic score decay, context extension or speed guarantee.",
    "Other pair layouts can be valid with consistent conventions."
  ]
}

۵. چهار پرسش دربارهٔ فاصله، چیدمان و حدِ نتیجه

پرسش اول: چرا شاهدِ نخست −4/5 است و نه +4/5؟ پاسخ: در چرخشِ ستونیِ تعریف‌شده، (0,1) به (−4/5,3/5) می‌رود. ضرب با (1,0)، مؤلفهٔ اول را برمی‌دارد. اختلافِ موقعیت n−m و علامتِ درایهٔ بالای راستِ R باید با هم سازگار باشند؛ عوض‌کردنِ قرارداد بدونِ تغییرِ فرمول، جواب را برعکس می‌کند.

پرسش دوم: برای جا دادنِ دو کلید در خانه‌های صفر و یک، شناسه‌ها را هم صفر و یک کنیم؟ پاسخ: نه به‌عنوانِ یک تبدیلِ بی‌اثرِ عمومی. در شاهدِ موقعیت‌های یک و سه، فشرده‌کردنِ شکاف یک اختلاف را عوض کرد و امتیازِ اول تغییر کرد. جابه‌جاییِ مشترک که همهٔ اختلاف‌ها را حفظ کند، شرطِ متفاوتی دارد؛ خانهٔ ذخیره نباید بی‌دلیل جای شناسه را بگیرد.

پرسش سوم: چون اندازه‌ها ثابت‌اند، همهٔ امتیازها ثابت یا با فاصله نزولی‌اند؟ پاسخ: خیر؛ اندازهٔ دو بردار، زاویهٔ میانشان را تعیین نمی‌کند. چرخشِ مشترک ضرب داخلی را حفظ می‌کند، ولی چرخش‌های متفاوت زاویهٔ نسبی را تغییر می‌دهند. از هویتِ نسبی، افتِ یکنواختِ تک‌تکِ امتیازها نتیجه نمی‌شود؛ تحلیلِ یک الگوی فرکانسی را نمی‌توان به هر ورودیِ دلخواه تعمیم داد.

پرسش چهارم: این آزمون، افزایشِ طولِ زمینه یا کیفیتِ پاسخ را ثابت می‌کند؟ پاسخ: خیر؛ مرجعِ جاریِ RoPE در Transformers تنظیم‌های پیش‌فرض، مقیاس‌شده و چندوجهیِ متفاوت دارد. این مثال هیچ‌کدام را اجرا نمی‌کند و تنها هندسهٔ یک جدولِ کسریِ ساختگی را می‌سنجد. نخستین نسخهٔ مقاله در ۲۰ آوریلِ ۲۰۲۱ و v5 در ۸ نوامبرِ ۲۰۲۳ ثبت شده‌اند؛ منبعِ arXiv را بدونِ ادعای وضعیتِ داوری می‌خوانیم. دسترسیِ منابع در ۳۰ مهرِ ۱۴۰۵ است؛ صفحهٔ HF شاخهٔ main و دارای اشاره به stable 5.20.2 بود، نه اجرای آن نسخه. تاریخِ نخستین انتشارِ آن صفحه معلوم نیست. دو پیوندِ مرتبط از موجودیِ موفقِ ذخیره‌شدهٔ ۲۹ مهر، ساعتِ ۱۶:۳۸ تهران انتخاب شده‌اند؛ بررسیِ زندهٔ تازه‌ای برایشان ادعا نشده است.

منابع و مطالعهٔ بیشتر

• RoFormer v5؛ تعریف و مشتق‌گیریِ چرخشِ موقعیت
• مستنداتِ جاریِ Transformers؛ گونه‌ها و تنظیماتِ RoPE

بررسی منابع: ۳۰ مهر ۱۴۰۵. تحلیل‌ها و پیشنهادهای اجرایی، جمع‌بندی نویسنده‌اند.