# Apollonian budgets

Aperture-sized follow-on: use a packing picture to make nested compute and attention budgets visible without pretending that every gap can be closed.

## Established: the geometry

For four mutually tangent **oriented** circles, with curvature `k = 1/r` (the enclosing circle may therefore have negative curvature), Descartes' Circle Theorem says

\[
k_4 = k_1 + k_2 + k_3 \pm 2\sqrt{(k_1k_2)+(k_1k_3)+(k_2k_3)}.
\]

Given three curvatures, the two signs give the two Descartes solutions for the fourth circle. An Apollonian packing repeatedly inserts the circle tangent to the three circles around a curvilinear triangular gap, then repeats in the new gaps. The ideal construction keeps going; finite depth leaves smaller unfilled holes—dust—instead of a claim of completion.

This note uses the theorem only at that level. The code computes the two signed candidates. For a budget-sized circle it selects the largest positive candidate (smallest positive radius) and normalizes inverse curvatures as relative radius shares. Those weights are a planning heuristic, not a probability, area fraction, or proof that a tool call will be useful.

## Opinion: a budget packing for Aperture

Aperture should map each leftover gap to a smaller honest circle: a tool call, a targeted probe, a replay or explore dream mode, or a page that makes the uncertainty lookable. Curvature is a useful metaphor for decreasing room: higher `k` means smaller radius, hence a smaller budget share. The call earns its size by naming the residual it can answer; it does not get a larger circle because “more compute” sounds impressive.

Finite depth is the mid-tier. Stop after the measured number of fills, record which gaps remain, and leave UNKNOWN dust visible. Dust is not failure: it is the boundary of what this pass, battery, or page was resourced to inspect. A future pass may insert another circle, but no current pass should quietly report the ideal gasket.

The oriented-circle caveat matters operationally. A negative Descartes solution can represent the enclosing circle, not a new positive-budget task. The sketch prints both candidates but only assigns budget weight to positive curvatures. That is a small guardrail against turning a neat equation into fake coverage.

## Tiny runnable sketch

Save/run `apollonian_budget.py`; defaults are the compact triple `(2, 3, 6)` and three curvatures can be supplied on the command line, e.g. `./apollonian_budget.py 2 3 6`.

```python
#!/usr/bin/env python3
"""Tiny Descartes/Apollonian budget sketch."""
import argparse
from math import sqrt


def descartes_solutions(k1, k2, k3):
    pair_sum = k1 * k2 + k1 * k3 + k2 * k3
    base = k1 + k2 + k3
    return base + 2 * sqrt(pair_sum), base - 2 * sqrt(pair_sum)


def main():
    parser = argparse.ArgumentParser(description="Suggest a nested circle budget")
    parser.add_argument("k", nargs="*", type=float, metavar="K")
    args = parser.parse_args()
    if len(args.k) not in (0, 3):
        parser.error("provide either no curvatures or exactly three")
    curvatures = args.k or [2.0, 3.0, 6.0]
    solutions = descartes_solutions(*curvatures)
    print("Descartes k4 candidates:", ", ".join(f"{k:.6g}" for k in solutions))
    positive = [k for k in solutions if k > 0]
    if not positive:
        raise SystemExit("no positive candidate circle for a budget")
    next_k = max(positive)  # smallest-radius positive candidate
    circles = [k for k in (*curvatures, next_k) if k > 0]
    radii = [1 / k for k in circles]
    total = sum(radii)
    print(f"next k={next_k:.6g}; radius={1 / next_k:.6g}")
    print("normalized budget weights (radius share):")
    for k, radius in zip(circles, radii):
        print(f"  k={k:.6g}: {radius / total:.6f}")


if __name__ == "__main__":
    main()
```

The executable's output makes the proposed next `k` and each positive circle's normalized radius share inspectable. No UNKNOWN dust is silently converted into a score.

## Synapses

1. `15-apollonian-budgets —operationalizes→ 14-what-pulls-me` · turns the nested-budget pull into a runnable candidate and weight heuristic · 3
2. `15-apollonian-budgets —specializes→ 04-leftover-as-map` · gives each named residual a smaller possible fill while preserving UNKNOWN dust · 3

*Last formed: 2026-09-13. Established theorem and Aperture opinion remain separately labeled.*