"""Exact scalar contraction scheduling with at most one split request.

All arithmetic uses fractions.Fraction. A fragment (i, a) applies
    x <- a*x + (1-a)*centers[i].
The product of the fragment retentions for request i equals retentions[i].
This is an enlarged scheduling policy: at most n+1 updates replace n updates.
No claim of preserving a gradient-query count or sum of step sizes is made.
"""

from fractions import Fraction


def execute_fragments(centers, fragments, initial=0):
    """Evaluate a fragment list exactly."""
    x = Fraction(initial)
    centers = tuple(map(Fraction, centers))
    for i, retention in fragments:
        a = Fraction(retention)
        x = a * x + (1 - a) * centers[i]
    return x


def optimal_one_split_order(centers, retentions, initial=0, target=0):
    """Globally minimize squared terminal error over all finite fragmentations.

    Rational retentions must be in [0,1]. The returned policy splits at most
    one request into two fragments, each with the same target as its parent.
    The algorithm makes O(n**2) exact rational operations, apart from sorting;
    all rational operands have polynomial binary length in the input.
    It also returns the optimal squared error and the full attainable interval.
    """
    centers = tuple(map(Fraction, centers))
    retentions = tuple(map(Fraction, retentions))
    initial, target = Fraction(initial), Fraction(target)
    n = len(centers)
    if len(retentions) != n:
        raise ValueError("centers and retentions must have equal length")
    if any(a < 0 or a > 1 for a in retentions):
        raise ValueError("retentions must lie in [0,1]")

    minimum_order = sorted(range(n), key=lambda i: -centers[i])
    maximum_order = sorted(range(n), key=lambda i: centers[i])

    def unsplit(order):
        return [(i, retentions[i]) for i in order]

    minimum = execute_fragments(centers, unsplit(minimum_order), initial)
    maximum = execute_fragments(centers, unsplit(maximum_order), initial)
    best_endpoint = min(max(target, minimum), maximum)

    def result(fragments, split_request, swaps):
        endpoint = execute_fragments(centers, fragments, initial)
        return {
            "fragments": fragments,
            "split_request": split_request,
            "endpoint": endpoint,
            "objective": (endpoint - target) ** 2,
            "optimal_endpoint": best_endpoint,
            "attainable_interval": (minimum, maximum),
            "adjacent_swaps_examined": swaps,
        }

    if target <= minimum:
        return result(unsplit(minimum_order), None, 0)
    if target >= maximum:
        return result(unsplit(maximum_order), None, 0)

    # A bubble-sort path increases the endpoint from minimum to maximum.
    order = minimum_order[:]
    suffix = [Fraction(1)] * (n + 1)
    for p in range(n - 1, -1, -1):
        suffix[p] = retentions[order[p]] * suffix[p + 1]
    current = minimum
    swaps = 0
    for end in range(n - 1, 0, -1):
        for p in range(end):
            i, j = order[p], order[p + 1]
            if centers[i] <= centers[j]:
                continue
            ai, aj = retentions[i], retentions[j]
            later = suffix[p + 2]
            increment = later * (1 - ai) * (1 - aj) * (centers[i] - centers[j])
            following = current + increment
            swaps += 1
            if increment > 0 and current <= target <= following:
                lam = (target - current) / increment
                if lam == 0:
                    return result(unsplit(order), None, swaps)
                if lam == 1:
                    next_order = order[:]
                    next_order[p], next_order[p + 1] = j, i
                    return result(unsplit(next_order), None, swaps)
                # Final retention v interpolates the two adjacent endpoints.
                # The first retention ai/v keeps request i's total unchanged.
                v = 1 - lam * (1 - ai)
                first = ai / v  # v>0 for an interior interpolation, even if ai=0.
                fragments = (
                    unsplit(order[:p])
                    + [(i, first), (j, aj), (i, v)]
                    + unsplit(order[p + 2 :])
                )
                return result(fragments, i, swaps)
            order[p], order[p + 1] = j, i
            suffix[p + 1] = ai * later
            current = following
    raise ArithmeticError("attainable interval was not crossed")


if __name__ == "__main__":
    answer = optimal_one_split_order([-1, 1], [Fraction(1, 2)] * 2)
    print(answer)