تقریبِ نسبتِ فرکانس با پایتون؛ سقفِ مخرج با بودجهٔ خطا یکی نیست

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

۱. نسبتِ مطلوب را از محدودیتِ نمایش جدا کنیم

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

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

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

۲. ورودیِ دقیق، واحد هرتز و قراردادِ سقف مخرج

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

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

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

۳. کسرِ نزدیک را بسازیم و خطایش را جدا بسنجیم

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

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

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

"""Bounded rational frequency ratios; authored fixtures, never hardware data."""
from fractions import Fraction
from math import gcd
import json
import platform
import sys
from unittest.mock import patch


MAX_RATIO = 8
MAX_INPUT_DENOMINATOR = 64
MAX_REFERENCE_HZ = 1_000_000
MAX_CANDIDATE_DENOMINATOR = 16
MAX_BUDGET_NUMERATOR = 1_000_000


def exact_integer(value, name, low, high):
    if type(value) is not int:
        raise TypeError(name + " must be an exact int, not bool or a coercion")
    if not low <= value <= high:
        raise ValueError(name + " outside the owned educational bounds")
    return value


def exact_fraction(value, name, maximum, max_numerator):
    if type(value) is not Fraction:
        raise TypeError(name + " must be an exact Fraction")
    if not 0 <= value <= maximum:
        raise ValueError(name + " outside the nonnegative value bounds")
    if value.numerator > max_numerator or value.denominator > MAX_INPUT_DENOMINATOR:
        raise ValueError(name + " has an outside numerator or denominator")
    return value


def plan_ratio(requested_ratio, reference_hz, denominator_cap, budget_hz):
    """Choose a closest ratio, then independently apply the absolute Hz budget.

    This is a pure synthetic multiplier model. Denominator capacity is not
    a bound on the numerator, frequency error, oscillator quality or jitter.
    Only the small domain below is an owned public input contract.
    """
    ratio = exact_fraction(requested_ratio, "requested_ratio", MAX_RATIO, 512)
    reference = exact_integer(reference_hz, "reference_hz", 1, MAX_REFERENCE_HZ)
    cap = exact_integer(denominator_cap, "denominator_cap", 1,
                        MAX_CANDIDATE_DENOMINATOR)
    budget = exact_fraction(budget_hz, "budget_hz", MAX_BUDGET_NUMERATOR,
                            MAX_BUDGET_NUMERATOR)
    candidate = ratio.limit_denominator(cap)
    desired_hz = reference * ratio
    achieved_hz = reference * candidate
    signed_error_hz = achieved_hz - desired_hz
    absolute_error_hz = abs(signed_error_hz)
    return {
        "requested_ratio": ratio,
        "reference_hz": reference,
        "denominator_cap": cap,
        "candidate_ratio": candidate,
        "desired_hz": desired_hz,
        "achieved_hz": achieved_hz,
        "signed_error_hz": signed_error_hz,
        "absolute_error_hz": absolute_error_hz,
        "budget_hz": budget,
        "accepted": absolute_error_hz <= budget,
    }


def integer_pair_oracle(numerator, denominator, cap):
    """Finite oracle: enumerate integer pairs, no Fraction or continued fractions.

    Fixture assumptions: 0 <= numerator/denominator <= 8, denominator > 0,
    and cap <= 16. A closer candidate need never be outside [0, 8]: both
    endpoints are available with denominator one. This is a small reference,
    not an implementation recommendation for a large denominator budget.
    """
    seen = set()
    best = None
    best_distance_numerator = None
    for q in range(1, cap + 1):
        for p in range(0, MAX_RATIO * q + 1):
            divisor = gcd(p, q)
            a, b = p // divisor, q // divisor
            if (a, b) in seen:
                continue
            seen.add((a, b))
            distance_numerator = abs(a * denominator - numerator * b)
            if best is None:
                take = True
            else:
                left = distance_numerator * best[1]
                right = best_distance_numerator * b
                take = left < right
                if left == right:
                    take = b < best[1] or (
                        b == best[1] and a * best[1] < best[0] * b)
            if take:
                best = (a, b)
                best_distance_numerator = distance_numerator
    return best


def rejects(error_types, function, *args):
    try:
        function(*args)
    except error_types:
        return True
    return False


def json_report(report):
    return {key: str(value) if type(value) is Fraction else value
            for key, value in report.items()}


def run_example():
    requested = Fraction(7, 10)
    manual = plan_ratio(requested, 3000, 4, Fraction(99))
    equality = plan_ratio(requested, 3000, 4, Fraction(100))
    exact = plan_ratio(requested, 3000, 10, Fraction(0))
    checks = {}
    checks["manual_ratio_has_signed_minus_100_Hz_error_and_rejects_99_Hz"] = (
        manual["candidate_ratio"] == Fraction(2, 3)
        and manual["desired_hz"] == 2100
        and manual["achieved_hz"] == 2000
        and manual["signed_error_hz"] == -100
        and manual["absolute_error_hz"] == 100
        and manual["accepted"] is False)
    checks["absolute_Hz_budget_is_inclusive_at_equality_not_a_ratio_tolerance"] = (
        equality["accepted"] is True
        and equality["candidate_ratio"] == manual["candidate_ratio"]
        and equality["absolute_error_hz"] == equality["budget_hz"])
    checks["already_representable_target_is_exact_and_zero_budget_passes"] = (
        exact["candidate_ratio"] == requested
        and exact["signed_error_hz"] == 0 and exact["accepted"] is True)

    integer_ties = [plan_ratio(Fraction(n, 2), 1, 1, Fraction(1))
                    for n in (5, 7)]
    checks["CPython_3145_cap_one_midpoints_choose_lower_not_half_even"] = (
        [x["candidate_ratio"] for x in integer_ties] == [Fraction(2), Fraction(3)]
        and round(Fraction(7, 2)) == 4)
    smaller_denominator_ties = [
        plan_ratio(Fraction(n, 4), 4, 2, Fraction(1)) for n in (1, 3)]
    checks["equal_distance_prefers_smaller_reduced_denominator_not_always_lower"] = (
        [x["candidate_ratio"] for x in smaller_denominator_ties]
        == [Fraction(0), Fraction(1)]
        and all(x["absolute_error_hz"] == 1 for x in smaller_denominator_ties))

    fixed_denominator_candidate = Fraction(3, 4)
    fixed_grid_error = abs(3000 * (fixed_denominator_candidate - requested))
    checks["cap_is_an_upper_bound_not_a_fixed_denominator_grid"] = (
        manual["candidate_ratio"].denominator == 3 < 4
        and fixed_grid_error == 150 > manual["absolute_error_hz"])
    ladder = [plan_ratio(requested, 3000, cap, Fraction(100))
              for cap in range(1, MAX_CANDIDATE_DENOMINATOR + 1)]
    checks["larger_cap_never_worsens_optimal_error_but_may_not_change_candidate"] = (
        all(a["absolute_error_hz"] >= b["absolute_error_hz"]
            for a, b in zip(ladder, ladder[1:]))
        and ladder[3]["candidate_ratio"] == ladder[4]["candidate_ratio"]
        and ladder[3]["signed_error_hz"] < 0 < ladder[6]["signed_error_hz"]
        and all(x["absolute_error_hz"] == 0 for x in ladder[9:]))

    scaled = plan_ratio(requested, 9000, 4, Fraction(300))
    unscaled_budget = plan_ratio(requested, 9000, 4, Fraction(100))
    checks["reference_Hz_scales_error_and_budget_while_ratio_stays_fixed"] = (
        scaled["candidate_ratio"] == equality["candidate_ratio"]
        and scaled["signed_error_hz"] == 3 * equality["signed_error_hz"]
        and scaled["accepted"] is True and unscaled_budget["accepted"] is False)
    zero_cases = [plan_ratio(Fraction(0), hz, cap, Fraction(0))
                  for hz in (1, MAX_REFERENCE_HZ)
                  for cap in (1, MAX_CANDIDATE_DENOMINATOR)]
    checks["zero_requested_ratio_is_exact_at_frequency_and_cap_endpoints"] = all(
        x["candidate_ratio"] == 0 and x["candidate_ratio"].denominator == 1
        and x["achieved_hz"] == 0 and x["accepted"] is True for x in zero_cases)

    class FractionChild(Fraction):
        pass

    consumed = []

    def forbidden_generator():
        consumed.append(True)
        yield 1

    bad_types = []
    valid_args = [requested, 3000, 4, Fraction(100)]
    for index, values in [
        (0, [True, 1, 0.7, "7/10", complex(1), FractionChild(7, 10),
             forbidden_generator()]),
        (1, [True, Fraction(3000), 3000.0, "3000", None]),
        (2, [True, Fraction(4), 4.0, "4", None]),
        (3, [False, 100, 100.0, "100", None, FractionChild(100)]),
    ]:
        for value in values:
            args = valid_args.copy()
            args[index] = value
            bad_types.append(tuple(args))
    checks["strict_types_reject_coercion_subclasses_and_unconsumed_generator"] = (
        all(rejects(TypeError, plan_ratio, *args) for args in bad_types)
        and consumed == [])

    bad_bounds = []
    for index, values in [
        (0, [Fraction(-1, 2), Fraction(9), Fraction(1, 65)]),
        (1, [0, MAX_REFERENCE_HZ + 1]),
        (2, [0, MAX_CANDIDATE_DENOMINATOR + 1]),
        (3, [Fraction(-1), Fraction(MAX_BUDGET_NUMERATOR + 1), Fraction(1, 65)]),
    ]:
        for value in values:
            args = valid_args.copy()
            args[index] = value
            bad_bounds.append(tuple(args))
    endpoint = plan_ratio(Fraction(8), MAX_REFERENCE_HZ,
                          MAX_CANDIDATE_DENOMINATOR,
                          Fraction(MAX_BUDGET_NUMERATOR))
    rational_endpoint = plan_ratio(Fraction(511, 64), 1, 16,
                                   Fraction(999_999, 64))
    checks["owned_value_numerator_denominator_and_capacity_bounds_are_explicit"] = (
        all(rejects(ValueError, plan_ratio, *args) for args in bad_bounds)
        and endpoint["candidate_ratio"] == 8
        and endpoint["achieved_hz"] == 8_000_000
        and endpoint["accepted"] is True and rational_endpoint["accepted"] is True)

    def approximation_must_not_run(*args, **kwargs):
        raise AssertionError("invalid public input reached the approximation")

    with patch.object(Fraction, "limit_denominator", approximation_must_not_run):
        prevalidated = all(rejects((TypeError, ValueError), plan_ratio, *args)
                           for args in bad_types + bad_bounds)
    checks["all_public_arguments_are_validated_before_library_approximation"] = (
        prevalidated and consumed == [])

    before = tuple(valid_args)
    first = plan_ratio(*valid_args)
    second = plan_ratio(*valid_args)
    first["candidate_ratio"] = Fraction(8)
    first["accepted"] = False
    checks["fresh_report_mappings_do_not_mutate_inputs_or_other_results"] = (
        tuple(valid_args) == before and requested == Fraction(7, 10)
        and second == equality and first is not second)

    profiles = set()
    for n in range(25):
        for d in range(1, 13):
            if n <= MAX_RATIO * d:
                divisor = gcd(n, d)
                profiles.add((n // divisor, d // divisor))
    oracle_passed = True
    queries = 0
    accepted_queries = 0
    for n, d in sorted(profiles):
        for cap in range(1, 9):
            a, b = integer_pair_oracle(n, d, cap)
            for hz in (300, 3000):
                budget = Fraction(100, 3)
                actual = plan_ratio(Fraction(n, d), hz, cap, budget)
                signed_numerator = hz * (a * d - n * b)
                error_denominator = b * d
                expected_acceptance = (
                    abs(signed_numerator) * budget.denominator
                    <= budget.numerator * error_denominator)
                error = actual["signed_error_hz"]
                oracle_passed = oracle_passed and (
                    (actual["candidate_ratio"].numerator,
                     actual["candidate_ratio"].denominator) == (a, b)
                    and error.numerator * error_denominator
                    == signed_numerator * error.denominator
                    and actual["accepted"] is expected_acceptance)
                queries += 1
                accepted_queries += int(expected_acceptance)
    checks["independent_integer_pair_exhaustive_family_is_ONE_group"] = oracle_passed
    if len(checks) != 14 or not all(type(v) is bool and v for v in checks.values()):
        raise AssertionError(checks)
    return {
        "runtime": {"python": platform.python_version(),
                    "implementation": platform.python_implementation()},
        "scope": "authored exact-rational frequency multiplier only; no hardware, timing, physical calibration or CI service",
        "dependencies": "Python standard library only",
        "units": {"ratio": "dimensionless", "frequency_and_error": "Hz"},
        "input_caps": {"requested_ratio_range": [0, 8],
                       "requested_numerator_max": 512,
                       "input_denominator_max": MAX_INPUT_DENOMINATOR,
                       "reference_hz_range": [1, MAX_REFERENCE_HZ],
                       "candidate_denominator_cap_range": [1, MAX_CANDIDATE_DENOMINATOR],
                       "nonnegative_budget_numerator_max": MAX_BUDGET_NUMERATOR},
        "tie_scope": "CPython 3.14.5 implementation: smaller reduced denominator, then lower integer midpoint; not an extra public-API promise",
        "manual_rejected": json_report(manual),
        "manual_budget_equality": json_report(equality),
        "manual_exact_with_cap_10": json_report(exact),
        "fixed_denominator_4_error_hz": str(fixed_grid_error),
        "cap_ladder": [{"cap": x["denominator_cap"],
                        "candidate": str(x["candidate_ratio"]),
                        "signed_error_hz": str(x["signed_error_hz"])} for x in ladder],
        "invalid_type_cases_inside_ONE_group": len(bad_types),
        "invalid_bound_cases_inside_ONE_group": len(bad_bounds),
        "independent_family": {"distinct_normalized_profiles_inside_ONE_group": len(profiles),
                               "queries_inside_ONE_group": queries,
                               "accepted_queries": accepted_queries,
                               "rejected_queries": queries - accepted_queries,
                               "oracle": "integer numerator/denominator enumeration with gcd and exact cross products, no Fraction or continued-fraction algorithm in candidate oracle"},
        "checks": checks,
        "meaningful_named_groups": len(checks),
    }


if __name__ == "__main__":
    payload = json.dumps(run_example(), ensure_ascii=True, indent=2,
                         allow_nan=False) + "\n"
    sys.stdout.buffer.write(payload.encode("utf-8"))

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

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

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

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

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

{
  "runtime": {
    "python": "3.14.5",
    "implementation": "CPython"
  },
  "scope": "authored exact-rational frequency multiplier only; no hardware, timing, physical calibration or CI service",
  "dependencies": "Python standard library only",
  "units": {
    "ratio": "dimensionless",
    "frequency_and_error": "Hz"
  },
  "input_caps": {
    "requested_ratio_range": [
      0,
      8
    ],
    "requested_numerator_max": 512,
    "input_denominator_max": 64,
    "reference_hz_range": [
      1,
      1000000
    ],
    "candidate_denominator_cap_range": [
      1,
      16
    ],
    "nonnegative_budget_numerator_max": 1000000
  },
  "tie_scope": "CPython 3.14.5 implementation: smaller reduced denominator, then lower integer midpoint; not an extra public-API promise",
  "manual_rejected": {
    "requested_ratio": "7/10",
    "reference_hz": 3000,
    "denominator_cap": 4,
    "candidate_ratio": "2/3",
    "desired_hz": "2100",
    "achieved_hz": "2000",
    "signed_error_hz": "-100",
    "absolute_error_hz": "100",
    "budget_hz": "99",
    "accepted": false
  },
  "manual_budget_equality": {
    "requested_ratio": "7/10",
    "reference_hz": 3000,
    "denominator_cap": 4,
    "candidate_ratio": "2/3",
    "desired_hz": "2100",
    "achieved_hz": "2000",
    "signed_error_hz": "-100",
    "absolute_error_hz": "100",
    "budget_hz": "100",
    "accepted": true
  },
  "manual_exact_with_cap_10": {
    "requested_ratio": "7/10",
    "reference_hz": 3000,
    "denominator_cap": 10,
    "candidate_ratio": "7/10",
    "desired_hz": "2100",
    "achieved_hz": "2100",
    "signed_error_hz": "0",
    "absolute_error_hz": "0",
    "budget_hz": "0",
    "accepted": true
  },
  "fixed_denominator_4_error_hz": "150",
  "cap_ladder": [
    {
      "cap": 1,
      "candidate": "1",
      "signed_error_hz": "900"
    },
    {
      "cap": 2,
      "candidate": "1/2",
      "signed_error_hz": "-600"
    },
    {
      "cap": 3,
      "candidate": "2/3",
      "signed_error_hz": "-100"
    },
    {
      "cap": 4,
      "candidate": "2/3",
      "signed_error_hz": "-100"
    },
    {
      "cap": 5,
      "candidate": "2/3",
      "signed_error_hz": "-100"
    },
    {
      "cap": 6,
      "candidate": "2/3",
      "signed_error_hz": "-100"
    },
    {
      "cap": 7,
      "candidate": "5/7",
      "signed_error_hz": "300/7"
    },
    {
      "cap": 8,
      "candidate": "5/7",
      "signed_error_hz": "300/7"
    },
    {
      "cap": 9,
      "candidate": "5/7",
      "signed_error_hz": "300/7"
    },
    {
      "cap": 10,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 11,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 12,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 13,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 14,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 15,
      "candidate": "7/10",
      "signed_error_hz": "0"
    },
    {
      "cap": 16,
      "candidate": "7/10",
      "signed_error_hz": "0"
    }
  ],
  "invalid_type_cases_inside_ONE_group": 23,
  "invalid_bound_cases_inside_ONE_group": 10,
  "independent_family": {
    "distinct_normalized_profiles_inside_ONE_group": 162,
    "queries_inside_ONE_group": 2592,
    "accepted_queries": 1467,
    "rejected_queries": 1125,
    "oracle": "integer numerator/denominator enumeration with gcd and exact cross products, no Fraction or continued-fraction algorithm in candidate oracle"
  },
  "checks": {
    "manual_ratio_has_signed_minus_100_Hz_error_and_rejects_99_Hz": true,
    "absolute_Hz_budget_is_inclusive_at_equality_not_a_ratio_tolerance": true,
    "already_representable_target_is_exact_and_zero_budget_passes": true,
    "CPython_3145_cap_one_midpoints_choose_lower_not_half_even": true,
    "equal_distance_prefers_smaller_reduced_denominator_not_always_lower": true,
    "cap_is_an_upper_bound_not_a_fixed_denominator_grid": true,
    "larger_cap_never_worsens_optimal_error_but_may_not_change_candidate": true,
    "reference_Hz_scales_error_and_budget_while_ratio_stays_fixed": true,
    "zero_requested_ratio_is_exact_at_frequency_and_cap_endpoints": true,
    "strict_types_reject_coercion_subclasses_and_unconsumed_generator": true,
    "owned_value_numerator_denominator_and_capacity_bounds_are_explicit": true,
    "all_public_arguments_are_validated_before_library_approximation": true,
    "fresh_report_mappings_do_not_mutate_inputs_or_other_results": true,
    "independent_integer_pair_exhaustive_family_is_ONE_group": true
  },
  "meaningful_named_groups": 14
}

۵. چهار پرسش پاسخ‌دار و مرزِ کاربرد نتیجه

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

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

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

پرسشِ چهارم: پذیرشِ این گزارش، یک ساعتِ سخت‌افزاری را تأیید می‌کند؟ پاسخ: خیر؛ محدودیتِ صورت، ساختارِ تقسیم‌کننده، خطای مرجع، جیتر و شرایطِ قطعه در مدل نیستند. این مقاله یک مصنوعِ آزمونِ عددی برای طراحیِ معیارِ پذیرش است؛ اجرای سرویسِ CI، آزمایشِ دستگاه یا مقایسهٔ سرعت نیست. مستنداتِ خوانده‌شده نسخهٔ 3.14.9، متنِ پیاده‌سازی و زمانِ اجرای مورد نظر 3.14.5 و تاریخِ دسترسی ۲۹ مهر ۱۴۰۵ است؛ تاریخِ نخستین انتشارِ صفحه‌ها نامعلوم می‌ماند.

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

• Python3.14؛ قراردادِ Fraction و نزدیک‌ترین کسر با سقفِ مخرج
• CPython3.14.5؛ متنِ کاملِ limit_denominator و قاعدهٔ تساویِ این پیاده‌سازی

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