| """Exact four-cap material packing, normalized to unit mass per cap. |
| |
| Input b[i][j] is the mass forbidden from pairing cap i toward cap j. |
| The three forbidden sectors at each cap are disjoint, so every row sum |
| is at most one. The construction returns symmetric edge flows obeying |
| x[i,j] <= 1-max(b[i][j], b[j][i]), sum_j x[i,j] <= 1, |
| and sum(x[i,j]**2) >= 5/9. |
| |
| This is an exact construction implementing the accompanying analytic |
| proof; finite test results are not a proof for all inputs. All arithmetic |
| uses fractions.Fraction. No numerical optimizer is used. |
| """ |
|
|
| from dataclasses import dataclass |
| from fractions import Fraction |
|
|
|
|
| EDGES = tuple((i, j) for i in range(4) for j in range(i + 1, 4)) |
|
|
|
|
| def edge(i, j): |
| return (i, j) if i < j else (j, i) |
|
|
|
|
| @dataclass(frozen=True) |
| class Packing: |
| flows: dict |
| owners: dict |
| case: str |
|
|
| def as_json(self): |
| return { |
| "flows": {f"{i}-{j}": str(x) for (i, j), x in self.flows.items()}, |
| "owners": {f"{i}-{j}": v for (i, j), v in self.owners.items()}, |
| "case": self.case, |
| } |
|
|
|
|
| def pack_bad_sectors(bad, owners=None): |
| """Return an exact feasible Packing for a four-by-four bad-mass array. |
| |
| Optional owners chooses either endpoint of each edge attaining its |
| maximum bad mass; it allows all tie orientations to be reproduced. |
| Otherwise ties go to the smaller endpoint. Diagonal entries must be |
| zero. Integers, Fraction objects, and rational strings are accepted. |
| """ |
| if len(bad) != 4 or any(len(row) != 4 for row in bad): |
| raise ValueError("bad must be a four-by-four array") |
| b = tuple(tuple(Fraction(x) for x in row) for row in bad) |
| for i, row in enumerate(b): |
| if row[i] != 0 or any(x < 0 for x in row) or sum(row) > 1: |
| raise ValueError("bad rows must be nonnegative, diagonal zero, sum <= 1") |
| capacity = {e: 1 - max(b[e[0]][e[1]], b[e[1]][e[0]]) for e in EDGES} |
| if owners is None: |
| own = {e: (e[0] if b[e[0]][e[1]] >= b[e[1]][e[0]] else e[1]) |
| for e in EDGES} |
| else: |
| own = dict(owners) |
| if set(own) != set(EDGES): |
| raise ValueError("owners must specify all six unordered edges") |
| for (i, j), v in own.items(): |
| if v not in (i, j) or b[v][j if v == i else i] != max(b[i][j], b[j][i]): |
| raise ValueError("an owner must attain the edge's maximum bad mass") |
| owned = {i: [e for e in EDGES if own[e] == i] for i in range(4)} |
| flows = {e: Fraction(0) for e in EDGES} |
|
|
| |
| sources = [i for i in range(4) if len(owned[i]) == 3] |
| if sources: |
| i = sources[0] |
| ordered = sorted(owned[i], key=lambda e: (-capacity[e], e)) |
| first, second = ordered[:2] |
| t = capacity[first] |
| flows[first], flows[second] = t, 1 - t |
| return Packing(flows, own, "source") |
|
|
| |
| pairs = [i for i in range(4) if len(owned[i]) == 2] |
| reduced = dict(capacity) |
| for i in pairs: |
| first, second = owned[i] |
| reduced[first] = capacity[first] |
| reduced[second] = 1 - reduced[first] |
| if reduced[first] < Fraction(1, 3) or reduced[first] > Fraction(2, 3): |
| flows[first], flows[second] = reduced[first], reduced[second] |
| return Packing(flows, own, "complementary_outlier") |
|
|
| u, v = pairs[:2] |
| if own[edge(u, v)] != u: |
| u, v = v, u |
| uw = next(e for e in owned[u] if e != edge(u, v)) |
| w = uw[0] if uw[1] == u else uw[1] |
| vw = edge(v, w) |
| vz = next(e for e in owned[v] if e != vw) |
| flows[vw], flows[vz] = reduced[vw], reduced[vz] |
| flows[uw] = min(reduced[uw], 1 - reduced[vw]) |
| return Packing(flows, own, "balanced_pair_and_third") |
|
|
