| """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) |
|
|
| |
| 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) |
| |
| |
| v = 1 - lam * (1 - ai) |
| first = ai / v |
| 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) |
|
|
