pbo.py

Go to the documentation of this file.

"""Probability of Backtest Overfitting (CSCV) over per-block moments: the exact stdlib reference.
 
Post hoc and pure. The input is an N x S table of block moments, one record per trial
(``{trial_id, status, block_returns: {status, count[S], sum[S], m2[S]}}``), never the T x N
return matrix. ``count`` is the number of intervals in a block, ``sum`` the sum of the
per-interval returns and ``m2`` the sum of squared deviations from the block mean. A row with
status ``ok`` or ``constraint_violation`` is computed (default D5); a failed, pruned or partial
row, or a payload that reports a non-positive equity, refuses with a code of its own. The rows
come in parts, each part with the result-level ``return_blocks`` object its rows were reduced
under plus a ``dataset_identity`` that the caller states (a call with one part passes a list of
one pair), and the caller declares the roster (the declared trial set). The module refuses
unless the parts declare one and the same object, every row's counts equal the ``n_b`` of its
own part's object, and the rows of all the parts together are exactly the roster. It checks what
it is handed: the grouping of the rows into parts and the object declared for each part are the
caller's. The module enumerates all C(S, S/2) ordered train/test splits of the S blocks, ranks
every trial on the training blocks, and reports how the training winner ranks on the
complementary blocks.
 
Every number is plain binary64 arithmetic in a fixed operation order, with no fused
operations and no tolerance. Counts and the sign of the logit are exact integer arithmetic; only
the logarithm of a logit value depends on the platform math library. Contract text and defaults:
``docs/pbo.md``.
Status: the native-proof PBO run uses synthetic data only; PBO on real data is not yet proven.
"""
 
from __future__ import annotations
 
from collections import Counter
from dataclasses import dataclass, field
from fractions import Fraction
import hashlib
from itertools import combinations
import json
import math
from typing import Any, Iterable, Iterator, Sequence
 
CONTRACT = "pineforge-hpo-pbo/v1"
ALGORITHM = "cscv-all-ordered-splits/v1"
STATISTIC = "pooled-mean-over-sample-sigma/v1"
 
CONSTRAINT_VIOLATION = "constraint_violation"
NON_POSITIVE_EQUITY = "non_positive_equity"
 
# Row statuses (default D5). A constraint-violating trial was tried, so it belongs to the roster
# and is computed like an ok trial. A failed, pruned or partial trial refuses, each with its own
# code; so does a payload whose status says an equity at or below zero skipped an interval.
ROSTER_ROW_STATUSES = (OK, CONSTRAINT_VIOLATION)
ERROR_ROW_STATUSES = (
    "error",
    "objective_error",
    "constraint_error",
    "engine_error",
    "trial_error",
    "trial_timeout",
)
PRUNED_ROW_STATUS = "pruned"
PARTIAL_ROW_STATUS = "partial"
 
# The result-level ``return_blocks`` object of the pinned wire (dossier clause 3.3) declares the
# layout the rows of a part were reduced under. These are its keys.
RETURN_BLOCKS_CONTRACT = "pineforge-hpo-return-blocks/v1"
RETURN_BLOCKS_SERIES = "bar"
RETURN_BLOCKS_KEYS = (
    "contract",
    "series",
    "S",
    "K",
    "n_b",
    "boundary_time_ms",
    "numeric_build_identity",
)
# The declared object of a part is that object plus one key of this API, not of the wire: the
# caller states a text that names the dataset the rows of the part were reduced over. Contract
# clause 3.5 refuses a dataset that differs between parts, and the interval count and the time
# axis alone cannot tell two datasets of the same length apart. Exactly the keys of
# ``DECLARED_OBJECT_KEYS`` are read; any other key refuses.
DATASET_IDENTITY_KEY = "dataset_identity"
DECLARED_OBJECT_KEYS = RETURN_BLOCKS_KEYS + (DATASET_IDENTITY_KEY,)
 
TIE_RULES = {
    "equality": "exact_binary64",
    "train_best": "mixture_weight_1_over_k",
    "oos_rank": "mid_rank",
}
 
INTERPRETATION = (
    "A deterministic frequency over the re-labellings of one dataset into training and testing "
    "halves. The composition of the trial roster moves it. For adaptive or correlated trials it "
    "is a diagnostic, not a probability under independent strategy draws."
)
 
PAPER_CONFORMANT_SAMPLERS = ("grid", "random", "sobol")
DIAGNOSTIC_SAMPLERS = ("tpe", "dlib_global", "candidates")
 
# A required keyword of ``pbo`` that was not passed (None is a value: no early stop).
 
 
CODES = (
    "pbo_input_invalid",
    "pbo_parameter_missing",
    "pbo_roster_mismatch",
    "pbo_return_blocks_mismatch",
    "pbo_block_sizes_uneven",
    "pbo_dataset_mismatch",
    "pbo_window_mismatch",
    "pbo_identity_mismatch",
    "pbo_rows_incomplete",
    "pbo_status_error",
    "pbo_status_pruned",
    "pbo_status_partial",
    "pbo_non_positive_equity",
    "pbo_odd_s",
    "pbo_too_few_trials",
    "pbo_zero_variance",
    "pbo_block_mismatch",
    "pbo_resource_exceeded",
    "pbo_sampler_unknown",
)
 
# When several kinds of row problems occur at once, the first kind in this order is reported
# (with every offending id of that kind), so the refusal does not depend on the row order.
# Every code that a row, or the comparison of the rows with the roster, can raise is listed.
 
 
 
 
 
 
 
 
 
 
 
# The fields in which the declared objects of two parts can differ (contract clause 3.5), with the
# code of each difference. K comes first: a different interval count is a different dataset (and
# changes n_b with it), and so is a different dataset identity; the same K with other counts is a
# different block layout. The contract, the series and S are not listed: every declared object
# must carry the fixed contract and series and the S of the call, so they cannot differ between
# parts that were accepted one by one.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
class PboError(Exception):
    """A refusal: a module-local ``pbo_`` code, one plain sentence, the offending trial ids and,
    when a call parameter is the offender, its name.
 
    ``code`` and ``ids`` are those of the first kind of problem in the fixed priority order.
    ``refusals`` names every kind that was found, in that order, each with its ``count`` and its
    offending ``ids`` (contract clause 3.5: counts per reason and offending ids), and
    ``coverage`` says how much of the declared roster the rows cover (``declared`` trials,
    ``supplied`` rows, ``usable`` declared trials whose row had no problem) when the rows were
    examined, else None; a refusal raised after the rows were accepted, such as a zero variance
    or a work figure above ``max_work``, carries it too. A refusal that was not found among rows
    has the one entry of its own code, counting its ids (or 1 when it has none).
    """
 
    def __init__(
        self,
        code: str,
        detail: str,
        ids: Iterable[Any] = (),
        names: Iterable[str] = (),
        *,
        coverage: dict[str, int] | None = None,
        refusals: Iterable[dict[str, Any]] | None = None,
    ) -> None:
        super().__init__(f"{code}: {detail}")
        self.code = code
        self.detail = detail
        self.ids = tuple(sorted(ids, key=_id_key))
        self.names = tuple(names)
        self.coverage = None if coverage is None else dict(coverage)
        if refusals is None:
            refusals = [{"code": code, "count": len(self.ids) or 1, "ids": self.ids}]
        self.refusals = tuple(
            {"code": item["code"], "count": item["count"], "ids": tuple(item["ids"])}
            for item in refusals
        )
 
    def document(self) -> dict[str, Any]:
        """The refusal as a JSON-ready document; it carries no number of the analysis."""
        return {
            "contract": CONTRACT,
            "status": "refused",
            "code": self.code,
            "detail": self.detail,
            "ids": list(self.ids),
            "names": list(self.names),
            "coverage": None if self.coverage is None else dict(self.coverage),
            "refusals": [
                {"code": item["code"], "count": item["count"], "ids": list(item["ids"])}
                for item in self.refusals
            ],
        }
 
 
 
 
 
 
 
 
 
@dataclass(frozen=True)
class MomentTable:
    """A validated N x S table of block moments; rows ascend by trial id.
 
    ``counts`` is common to every row and equals ``n_b`` of the declared object. ``sums[i][b]``
    and ``m2[i][b]`` belong to trial ``trial_ids[i]`` and block ``b``. ``return_blocks_json`` is
    the text of the declared object that every part declared.
 
    The table checks itself whenever it is built, whoever builds it: at least 2 trials, unique
    ascending ids of one type, arrays of the right lengths, counts equal to ``n_b``, finite
    moments, and the declared object itself (including the half-size rule). ``input_sha256`` is
    not an argument: it is computed from the content, so it cannot disagree with it. A refusal is
    a ``PboError``.
    """
 
    S: int
    trial_ids: tuple[Any, ...]
    counts: tuple[int, ...]
    sums: tuple[tuple[float, ...], ...]
    m2: tuple[tuple[float, ...], ...]
    return_blocks_json: str
    input_sha256: str = field(init=False)
 
    def __post_init__(self) -> None:
        size = _check_s(self.S)
        context = _table_context(self.return_blocks_json, size)
        ids = _table_ids(self.trial_ids)
        counts = self.counts
        if not isinstance(counts, (list, tuple)):
            raise PboError("pbo_input_invalid", "counts must be an array")
        if len(counts) != size:
            raise PboError(
                "pbo_block_mismatch",
                f"counts has {len(counts)} entries, expected S={size}",
            )
        if any(type(count) is not int for count in counts):
            raise PboError("pbo_input_invalid", "every count must be an integer")
        if list(counts) != context["n_b"]:
            raise PboError(
                "pbo_block_mismatch", "the counts differ from return_blocks.n_b"
            )
        raw_sums = _table_matrix("sums", self.sums, len(ids), size)
        raw_m2 = _table_matrix("m2", self.m2, len(ids), size)
        sums: list[tuple[float, ...]] = []
        m2s: list[tuple[float, ...]] = []
        for position, trial_id in enumerate(ids):
            try:
                blocks = [
                    _check_block(
                        index,
                        counts[index],
                        raw_sums[position][index],
                        raw_m2[position][index],
                    )
                    for index in range(size)
                ]
            except _RowProblem as problem:
                raise PboError(
                    problem.code, f"trial {trial_id!r}: {problem.detail}", [trial_id]
                ) from None
            sums.append(tuple(total for total, _ in blocks))
            m2s.append(tuple(centred for _, centred in blocks))
        object.__setattr__(self, "S", size)
        object.__setattr__(self, "trial_ids", ids)
        object.__setattr__(self, "counts", tuple(counts))
        object.__setattr__(self, "sums", tuple(sums))
        object.__setattr__(self, "m2", tuple(m2s))
        object.__setattr__(
            self, "return_blocks_json", _canonical(context).decode("ascii")
        )
        object.__setattr__(self, "input_sha256", _input_digest(ids, counts, sums, m2s))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
def load_moment_table(parts: Any, *, S: int, roster: Any = None) -> MomentTable:
    """Validate the parts (contract clause 3.5) and return the merged table sorted by trial id.
 
    ``parts`` is a list of ``(declared object, rows)`` pairs, one for each part of the lineage (a
    call with one part passes a list of one pair): the declared object is the result-level
    ``return_blocks`` object the rows of that part were reduced under, plus the
    ``dataset_identity`` that the caller states. ``roster`` is the declared trial set of the
    lineage. Both are required. The declared objects of all the parts must be
    one and the same, every row's counts must equal the ``n_b`` of its own part's object, and the
    rows of all the parts together must be exactly the roster. Refuses with ``PboError`` and
    never subsets: one bad row refuses the whole roster.
    """
    S = _check_s(S)
    declared_ids = _declared_ids(roster)
    return _load_parts(parts, S, declared_ids)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
def merge_moments(a: Triple, b: Triple) -> Triple:
    """Merge two ``(count, sum, m2)`` triples, ``a`` before ``b``, by the Chan/Pebay rule.
 
    ``M2 = M2a + M2b + d*d*na*nb/n`` with ``d = sum_b/nb - sum_a/na``. The operation order is
    pinned: ``(((d*d)*na)*nb)/n`` is formed first and added to ``(M2a + M2b)``; each operation
    is a separate binary64 step, so nothing is fused. The term added is never negative, hence
    neither is the result.
    """
    na, sa, ma = a
    nb, sb, mb = b
    n = na + nb
    d = sb / nb - sa / na
    t = d * d
    t = t * na
    t = t * nb
    t = t / n
    return n, sa + sb, (ma + mb) + t
 
 
def pooled_moments(blocks: Iterable[Triple]) -> Triple:
    """Merge the triples left to right in the order given (block order); the fold is pinned."""
    iterator = iter(blocks)
    try:
        n, s, m2 = next(iterator)
    except StopIteration:
        raise PboError("pbo_input_invalid", "there are no blocks to pool") from None
    pooled = (n, s, m2)
    for block in iterator:
        pooled = merge_moments(pooled, block)
    return pooled
 
 
def ranking_statistic(n: int, s: float, m2: float) -> float | None:
    """Pooled mean over sample sigma: ``(s/n) / sqrt(m2/(n-1))``; risk-free 0, unannualised.
 
    Returns None when the variance is exactly zero in binary64 (the caller refuses; a flat
    trial is never imputed). Refuses a count below 2 or a non-finite value.
    """
    if n < 2:
        raise PboError(
            "pbo_input_invalid", "the sample deviation needs at least 2 intervals"
        )
    if not (math.isfinite(s) and math.isfinite(m2)):
        raise PboError("pbo_input_invalid", "the pooled moments are not finite")
    if not m2 > 0.0:
        return None
    sigma = math.sqrt(m2 / (n - 1))
    if not sigma > 0.0:
        return None
    statistic = (s / n) / sigma
    if not math.isfinite(statistic):
        raise PboError("pbo_input_invalid", "the ranking statistic is not finite")
    return statistic
 
 
def estimate_work(S: int, N: int) -> dict[str, int]:
    """The admission figure of contract clause 3.7, exact integers, before any split is run.
 
    ``n_splits = C(S, S/2)``. Each complementary pair is evaluated once, so the merges are
    ``(n_splits/2) * N * (S - 2)``; the comparisons are ``2 * n_splits * N`` (a count of the
    selected trial's rank, not a sort). ``work`` is their sum.
    """
    S = _check_s(S)
    if type(N) is not int or N < 0:
        raise PboError("pbo_input_invalid", "N must be an integer that is not negative")
    n_splits = math.comb(S, S // 2)
    merges = (n_splits // 2) * N * (S - 2)
    comparisons = 2 * n_splits * N
    return {
        "n_splits": n_splits,
        "merges": merges,
        "comparisons": comparisons,
        "work": merges + comparisons,
    }
 
 
def roster_label(sampler: Any, *, early_stop: Any = _UNSET) -> str:
    """The roster label of default D6; an unknown or missing sampler refuses.
 
    ``diagnostic_adaptive_roster`` for an adaptive sampler and for any sampler whose study had a
    no-improvement early stop; ``paper_conformant`` for ``grid``, ``random`` and ``sobol`` without
    one. The early stop is not a sampler: it is a separate object of the result, so it is its own
    argument and ``"early_stop"`` is not a sampler name. As for ``pbo``, the caller must say
    whether the study had one (the result's ``early_stop`` object or ``True``; ``None`` or
    ``False`` when it had none): leaving it out refuses with ``pbo_parameter_missing``, so a study
    with an early stop cannot get ``paper_conformant`` by a default.
    """
    stopped = _check_early_stop(early_stop)
    if isinstance(sampler, str):
        if sampler in DIAGNOSTIC_SAMPLERS:
            return "diagnostic_adaptive_roster"
        if sampler in PAPER_CONFORMANT_SAMPLERS:
            return "diagnostic_adaptive_roster" if stopped else "paper_conformant"
    raise PboError(
        "pbo_sampler_unknown",
        f"sampler {sampler!r} is not one of "
        f"{', '.join(PAPER_CONFORMANT_SAMPLERS + DIAGNOSTIC_SAMPLERS)}",
    )
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
def iter_ordered_splits(S: int) -> Iterator[tuple[tuple[int, ...], tuple[int, ...]]]:
    """Yield every ordered ``(train, test)`` split: C(S, S/2) of them.
 
    Train is a size-S/2 subset of the blocks in original order and test is its complement.
    Order: the half that holds block 0, in lexicographic order, as train first and then as test.
    """
    return _ordered_splits(_check_s(S))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
def pbo(
    parts: Any,
    *,
    S: int,
    roster: Any = None,
    max_work: int | float | None = None,
    sampler: str | None = None,
    early_stop: Any = _UNSET,
    with_lambdas: bool = False,
) -> dict[str, Any]:
    """Run CSCV over every ordered split and return the result object (contract clause 3.6).
 
    ``parts`` is a list of ``(declared object, rows)`` pairs, one for each part of the lineage (a
    call with one part passes a list of one pair): the declared object is the result-level
    ``return_blocks`` object the rows of that part were reduced under, plus the
    ``dataset_identity`` that the caller states, and the rows are those that
    ``load_moment_table`` takes. A table is not accepted: it has lost its parts.
    ``roster`` (the declared trial set of the lineage) is required: the call refuses unless the
    declared objects of all the parts are one and the same, every row's counts equal the ``n_b``
    of its own part's object, and the rows of all the parts together are exactly the roster
    (contract clause 3.5). Block sizes may differ by at most one interval (default D2); the
    result then says ``equal_blocks: false`` and names ``block_counts``, and a larger spread
    refuses.
    ``sampler`` and ``early_stop`` (the result's ``early_stop`` object, or None when it has none)
    are both required and decide the roster label of default D6.
    Per split, the training winner is the trial with the largest ranking statistic; k tied
    winners (exact binary64 equality) each carry weight 1/k. Its out-of-sample rank is the
    mid-rank among the N trials, ``omega = rank / (N + 1)`` and
    ``lambda = ln(omega / (1 - omega))``. The primary rate ``pbo`` is the share of splits with
    lambda <= 0 (default D3); the share with lambda < 0 is reported next to it. A refusal raises
    ``PboError``; nothing partial is returned.
    """
    S = _check_s(S)
    _check_budget(max_work)
    stopped = _check_early_stop(early_stop)
    label = roster_label(sampler, early_stop=stopped)
    declared_ids = _declared_ids(roster)
    table = _load_parts(parts, S, declared_ids)
    n_trials = len(table.trial_ids)
    # Every row was accepted and the rows are the roster, so the three numbers are N. A refusal
    # from here on carries them: its rows were examined.
    coverage = {"declared": n_trials, "supplied": n_trials, "usable": n_trials}
    work = estimate_work(S, n_trials)
    if max_work is not None and work["work"] > max_work:
        raise PboError(
            "pbo_resource_exceeded",
            f"the estimated work {work['work']} (n_splits {work['n_splits']}, N {n_trials}, "
            f"S {S}) exceeds max_work {max_work}",
            coverage=coverage,
        )
    n_splits = work["n_splits"]
 
    below: dict[int, int] = {}
    atom: dict[int, int] = {}
    above: dict[int, int] = {}
    lambdas: list[float] = []
    tie_sizes: list[int] = []
    total = n_trials + 1
    for first, second in _partitions(S):
        stats_first = _half_statistics(table, first, coverage)
        stats_second = _half_statistics(table, second, coverage)
        for train, test in ((stats_first, stats_second), (stats_second, stats_first)):
            best = max(train)
            winners = [index for index, value in enumerate(train) if value == best]
            k = len(winners)
            for index in winners:
                reference = test[index]
                less = 0
                equal = 0
                for value in test:
                    if value < reference:
                        less += 1
                    elif value == reference:
                        equal += 1
                # twice the mid-rank: omega = rank / (N + 1), odds = omega / (1 - omega).
                twice_rank = 2 * less + equal + 1
                if twice_rank < total:
                    bucket = below
                elif twice_rank == total:
                    bucket = atom
                else:
                    bucket = above
                bucket[k] = bucket.get(k, 0) + 1
                if with_lambdas:
                    lambdas.append(math.log(twice_rank / (2 * total - twice_rank)))
                    tie_sizes.append(k)
 
    n_lt0 = _exact_count(below)
    n_eq0 = _exact_count(atom)
    n_gt0 = _exact_count(above)
    if n_lt0 + n_eq0 + n_gt0 != n_splits:
        raise RuntimeError(
            "internal accounting error: the split counts do not add up to n_splits"
        )
    rate_le0 = float((n_lt0 + n_eq0) / n_splits)
    result: dict[str, Any] = {
        "contract": CONTRACT,
        "algorithm": ALGORITHM,
        "status": OK,
        "S": S,
        "N": n_trials,
        "n_splits": n_splits,
        "equal_blocks": len(set(table.counts)) == 1,
        "block_counts": list(table.counts),
        "statistic": STATISTIC,
        "tie_rules": dict(TIE_RULES),
        "n_lt0": _count_value(n_lt0),
        "n_eq0": _count_value(n_eq0),
        "n_gt0": _count_value(n_gt0),
        "pbo": rate_le0,
        "rate_le0": rate_le0,
        "rate_lt0": float(n_lt0 / n_splits),
        "calibrated": False,
        "interpretation": INTERPRETATION,
        "sampler": sampler,
        "early_stop": stopped,
        "roster_label": label,
        "work_estimate": work["work"],
        "input_sha256": table.input_sha256,
        "return_blocks_sha256": hashlib.sha256(
            table.return_blocks_json.encode("ascii")
        ).hexdigest(),
        "coverage": dict(coverage),
        "refusals": [],
    }
    if with_lambdas:
        result["lambdas"] = lambdas
        result["lambda_tie_sizes"] = tie_sizes
    return result