HN 日本語サマリー

← 一覧へ戻る
科学・技術

n=17正方形パッキングのための、さらに改善された下限値

Another better lower bound for n=17 square packing (gus-massa.blogspot.com)

3 pointsby gus_massa0 コメント

要約

この記事では、17個の単位正方形を最小の正方形に詰め込む問題(n=17正方形パッキング)における、新しい下限値の発見について論じています。従来の境界値4.4452... ≤ s(17) ≤ 4.6756...に対し、Sam Burns氏がChatGPT 5.6 Solを用いて4.4811(?)という下限値を提案しましたが、この記事の著者はさらに改良を加え、4.5058(?)という新たな下限値を見出しました。この新しい下限値は、より洗練された点配置と線形計画法を用いた重み計算によって導き出されており、今後の研究への展望も示唆されています。

全文翻訳

n=17 正方形パッキングのための、もう一つのより良い下限値

このアイデアは、最近の結果を改善し、これらの重みを使用して 4.5058(?)≤s(17) を証明することです。

[画像]

まず、s(17) を定義しましょう。このトピックに関する古い記事から引用します。

s(n) を、n 個の単位正方形を詰め込むことができる最小の正方形の辺の長さとする。

n=16 の場合、最適なのは明らかに 4x4 の配列なので、s(16)=4 です。

n=15 の場合、15 個の単位正方形は明らかに 4x4 の正方形に収めることができるため、s(15)≤4 です。これが最小の正方形であることを証明するのは全く簡単ではありません。いずれにせよ、Erich Friedman は 1999 年にこれを証明したので、s(15)=4 です。

n=17 の場合、明らかな外接正方形は 5x5 ですが、1998 年に John Bidwell は 4.6756… の正方形で十分であることを示す例を見つけました。したがって、s(17)≤4.6756… です。これは非常に興味深い正方形の配置なので、コレクションを見てみる価値があります。他の数値のバージョンもあります。

一方、Trevor Green は 2000 年に 4.4452…≤s(17) を証明しました(詳細は後述)。そのため、4.4452…≤s(17)≤4.6756… という大きなギャップがありました。

数週間前、Sam Burns は ChapGPT 5.6 Sol と共に下限値を改善しました(?)。新しい下限値はまだコミュニティによってレビューされていません。私はそれを確認しましたが、非常に理にかなっており、正しいと考えていますが、証明の小さなコーナーケースや付属のプログラム、あるいは大きな穴を見落としている可能性があります。念のため数値に小さな(?)を追加しますが、私は非常に楽観的で確信しているので、フォントサイズは半分にします。したがって、現在の境界は 4.4452…≤4.4811(?)≤s(17)≤4.6756… です。

Sam Burns に対する私の主な異論は、本当に素敵なグラフィックに値するということです!したがって、私の最初のステップはここに素敵なグラフィックを追加することです。また、プログラムにいくつかの改善を加えたところ、新しい下限値 4.5058 を見つけました。これで、4.4452…≤4.4811(?)≤4.5058(?)≤s(17)≤4.6756… となります。

私の新しい例とコードの修正はここにありますが、新しい下限値を見つけるためのより技術的な詳細は2番目の投稿に含まれています。

Trevor Green の下限値

Trevor Green による (19+40*sqrt(2))/17≅4.4452…≤s(17) という古い証明のアイデアは、4.4452… の辺を持つ正方形内に 16 個の非常に興味深い「避けられない」点を選び、その後、多くの幾何学を用いて、任意の単位正方形が少なくとも 1 つの点を含むことを証明することです。したがって、そこに 17 個の単位正方形を詰め込もうとすると、少なくとも 2 つの単位正方形が 16 個の興味深い点のいずれかを共有しなければなりません。この構成では、4x6 のグリッドから 16 個の点を選択します。

私は古い記事で点の画像を見つけましたが、解析的な定義は見つかりませんでした。正方形の辺の公式を見て、規則といくつかの推測を使用すると、左右の空の余白は 0.5 で、上下の空の余白は sqrt(2)-1/2≅0.9142… であると考えられます。これらの選択により、元のグラフィックの対角線セグメントの長さは 1 となり、頂点が避けられない点である三角形を作成するのに非常に役立つ数値です。(確認していただけると嬉しいです。)

これは、0.9142… と 0.5000 の空の余白を持つ 6x4 グリッドを使用し、グリッドの合計サイズは 2.6168… と 2.4452… です。

[画像]

新しい構成と比較するために、対称化する方が良いでしょう。この対称化されたバージョンでは、各単位正方形は少なくとも 4 つの点を含みますが、一部の点は太く、二重の点としてカウントされます(詳細は後述)。

[画像]

Sam Burns の下限値

ChatGPT を使用して 4.4811(?)≤s(17) を証明するというアイデアは、Sam Burns によって投稿されました。彼は 4.4811 の辺を持つ正方形に 268 個のやや興味深い点を選びました。これらの点には異なる重みがあり、合計の重みは 16.9476 にすぎません。いくつかの削減の後、有限個の方角をテストするだけで済み、彼らはPythonでプログラムを使用して「すべて」の可能な「ほぼ単位」(実際には .9973)正方形をテストし、各正方形内の重みの合計が少なくとも 1(実際には 1.0003)であることを確認します。したがって、17 個の単位正方形をそこに詰め込もうとすると、少なくとも 2 つの単位正方形が 268 個のやや興味深い点のいずれかを共有しなければなりません。(2番目の投稿で詳細を確認。)

この方法には偽陰性があります。解を検証すれば、それは確かに正しいですが、プログラムが失敗した場合、間違いである可能性はごくわずかです。これは、重みが下限値を証明することを保証するのに適しています。

重みがどのように選択されたかは明らかではありません。この解を古い記事のすべての例と比較すると、0.5 の余白は狭すぎます。なぜなら、ほとんどの例では約 1.0 または約 9.1 などを使用しているからです。重みの選択は私と一致しており、グリッドの最初の/最後の行/列のすべての重みはゼロです。私の手探りの意見では、2番目/最後から2番目の行/列も空であるべきですが、グリッドの (1, 11) にはゼロ以外の重みがあり、対称な画像もあります。それがより良い例では必要ないことを願っています。3番目/最後から3番目の行/列はかなり満たされています。古い例よりも境界に近いので、境界の近くにより多くの点を追加することが下限値を改善するための良いアイデアのように見えます。

私はRacketとMetapictパッケージを使用して画像をレンダリングしました。各円の半径は、重みから次のように計算されます。

r = sqrt(weight^(1/gamma)) * scale

gamma = 1.0 の場合、面積は重みに比例しますが、小さい重みは画像では小さすぎます。調整後、gamma=2.0 は小さい重みが見やすくなるため、うまく機能します。スケールはそれほど神秘的ではなく、どこかで pi を使用すべきでしたが、scale=0.07 は私のマシンではうまく機能します。円は半透明なので、スケールを上げると重なりが見える可能性があります。コードは下にあり、重みを実際の最小合計である 1.0003 で割っています。

新しい下限値

私のアイデアは、余白と内部グリッドサイズのさまざまな組み合わせを試すことでした。前述のように、Sam Burns の例で重みがどのように選択されたかは明らかではありません。したがって、各固定サイズについて、それらを見つけるために線形計画法を使用することにしました。

その後、総当たり検索と運の組み合わせを使用して、見つけられる最良のグリッドを取得しました。その後、重みを丸めて、見栄えが良く、きれいな分数になるようにしました。(2番目の投稿で詳細を確認。)

長い時間をかけた結果、私が得た最良の結果は 4.5058(?)≤s(17) です。新しいソリューションは、4.5058 の辺を持つ正方形に 168 個のやや興味深い点を使用し、29x29 のグリッドに配置されます。それらの合計は 16.9166… にすぎません。各単位正方形は、少なくとも合計 1 の重みを含みます。0.77565 の空の余白があり、内部グリッドの合計辺は 2.9545 です。

[画像]

前述のように、重みは古い例で見たものよりも境界に近い位置にあります。前の例の 2 番目/最後から 2 番目の行/列に近い位置です。また、重みの数が少ないため、コンピュータなしで正しいことを証明するのが容易になることを願っています。非対称バージョンを見つけたいです。非対称バージョンは、おそらく重みの 1/8 であり、ほぼ正三角形を示し、コンピュータなしで理解しやすいはずです。

Sam Burns が公開したプログラムは、空の余白が 0.5 であると仮定しているため、任意の境界と二重の余白である変数 M を許可するようにわずかに変更する必要がありました。その変更、新しいサイズ、および新しい重みのテーブルを含むバージョンは下にあります。そのプログラムを実行し、Sam Burns が投稿した説明に明白な変更を加えることで、新しい下限値が証明(?)されます。

結論と今後の作業

  • 角の部分では分布はかなり離散的に見えますが、中央付近には奇妙なバーがあります。グリッドサイズを増やして確認するのは良いでしょう。また、狭い空の余白は役立つようです。
  • 2番目の記事にある私の検索プログラムは遅すぎます(約1時間)。そのため、グリッドサイズの変更は避けました。興味深い偶然の一致がある場合、他のグリッドサイズを探索することは有用かもしれません。
  • 桁数を増やすのに数分しかかかりませんでしたが、グリッドを洗練したり、回転のために複数の方向を使用したりする方が大きな変化をもたらすように思われたため、手間をかけませんでした。
  • この結果は、s(18)、s(19)、s(20) の下限値も自動的に改善します。しかし、これらの値についてより深い検索を行うと、さらに良い下限値が得られるはずです。合計の重みが 18 になるケースを何度も見ました。18 には何か興味深いものがあります。
  • 非対称バージョンを見つけたいです。試すアイデアがいくつかあるので、数日中に再度確認してください。非対称バージョンは、おそらく重みの 1/8 であり、ほぼ正三角形を示し、コンピュータなしで理解しやすいはずです。

新しい重みをどのようにして得たかの詳細については、2番目の投稿を読むとよいでしょう。

編集(複数)

2026年9月9日:

  • 「新しい下限値」セクションで、グリッドのサイズを誤った値 3.9545 から 2.9545 に修正しました。正方形の全長とプログラムの定数は正しかったです。
  • 結論で、非対称バージョンの検索に関するテキストを取り消し線で消しました。それは良いことですが、私の計画は失敗しました。

2026年9月11日:

  • グラフィックを描画するためのプログラムを修正しました。grid-n の代わりに (- grid-n 1) で割るべきでした。違いはほとんど見えませんが、グラフィックも更新しました。

バウンドを検証するためのプログラム

from __future__ import annotations

from bisect import bisect_left, bisect_right
from fractions import Fraction as F
import numpy as np

# Sam Burns 2026 によって投稿された元のバージョン
# Gustavo Massaccesi 2026 によって修正

# 正方形に 17 個の単位正方形をパッキングするための正確な下限証明。
#
# すべての幾何学的量と述語は有理数です。NumPy は整数範囲加算と累積和にのみ使用され、
# 浮動小数点幾何学は使用されません。

L = F(45058, 10000)   # 正方形の辺
M = F(15513, 10000)   # 両方の空の余白
B = F(9973, 10000)
T = F(207107, 500000)
KMAX = 180
D = T / KMAX
WEIGHT_SCALE = 576    # 最小重み
NGRID = 29
LAST = NGRID - 1

# (i, j, w): グリッドポイント (i,j) の各 D4 画像は重み w/WEIGHT_SCALE を受け取ります。
CERT = [
    (0, 2, 165),
    (0, 11, 129),
    (1, 8, 36),
    (1, 10, 21),
    (1, 11, 15),
    (2, 2, 246),
    (2, 8, 129),
    (2, 9, 105),
    (2, 10, 36),
    (2, 11, 105),
    (5, 10, 36),
    (6, 10, 63),
    (6, 11, 12),
    (7, 10, 21),
    (8, 9, 33),
    (8, 11, 15),
    (9, 11, 75),
    (9, 14, 39),
    (10, 11, 25),
    (10, 12, 21),
    (10, 13, 24),
    (10, 14, 3),
    (11, 11, 16)
]


def orbit(i: int, j: int) -> set[tuple[int, int]]:
    n = LAST
    return {
        (i, j), (n - i, j), (i, n - j), (n - i, n - j),
        (j, i), (n - j, i), (j, n - i), (n - j, n - i),
    }


def build_atoms() -> list[tuple[F, F, int]]:
    step = (L - M) / LAST
    coord = [M / 2 + step * i for i in range(NGRID)]
    by_index: dict[tuple[int, int], int] = {}
    for i, j, w in CERT:
        for ij in orbit(i, j):
            if ij in by_index:
                raise ValueError(f"duplicate orbit assignment at {ij}")
            by_index[ij] = w
    return [
        (coord[i], coord[j], w)
        for (i, j), w in sorted(by_index.items())
    ]


# 有理数凸多角形を U >= bound または U <= bound に対してクリップする。
def clip_u(
    poly: list[tuple[F, F]],
    bound: F,
    keep_ge: bool,
) -> list[tuple[F, F]]:
    if not poly:
        return []

    out: list[tuple[F, F]] = []

    def inside(p: tuple[F, F]) -> bool:
        return p[0] >= bound if keep_ge else p[0] <= bound

    prev = poly[-1]
    prev_in = inside(prev)
    for cur in poly:
        cur_in = inside(cur)
        if cur_in != prev_in:
            u1, v1 = prev
            u2, v2 = cur
            if u2 == u1:
                v = v1
            else:
                lam = (bound - u1) / (u2 - u1)
                v = v1 + lam * (v2 - v1)
            out.append((bound, v))
        if cur_in:
            out.append(cur)
        prev, prev_in = cur, cur_in
    return out


def center_domain(c: F, s: F) -> list[tuple[F, F]]:
    # 方向 (c,s) の B-正方形は、その中心が [h,L-h]^2 にある場合に [0,L]^2 にあります。
    # ここで h=B(c+s)/2 です。
    # その正方形を B-正方形の (U,V) フレームに変換します。
    h = B * (c + s) / 2
    lo, hi = h, L - h
    corners_xy = [(lo, lo), (hi, lo), (hi, hi), (lo, hi)]
    return [(c * x + s * y, -s * x + c * y) for x, y in corners_xy]


def verify_orientation(
    c: F,
    s: F,
    atoms: list[tuple[F, F, int]],
) -> int:
    """1 つの有理数方向に対する正確な最小整数スコアを返します。"""
    half = B / 2
    dom = center_domain(c, s)
    u_dom_min = min(u for u, _ in dom)
    u_dom_max = max(u for u, _ in dom)
    v_dom_min = min(v for _, v in dom)
    v_dom_max = max(v for _, v in dom)

    rects: list[tuple[F, F, F, F, int]] = []
    u_events = {u_dom_min, u_dom_max}
    v_events = {v_dom_min, v_dom_max}

    # 中心座標では、アトムのメンバーシップは軸に沿った長方形です。
    for x, y, w in atoms:
        pu = c * x + s * y
        pv = -s * x + c * y
        u1, u2 = pu - half, pu + half
        v1, v2 = pv - half, pv + half
        rects.append((u1, u2, v1, v2, w))
        u_events.add(u1)
        u_events.add(u2)
        v_events.add(v1)
        v_events.add(v2)

    ue = sorted(u_events)
    ve = sorted(v_events)
    ui = {x: i for i, x in enumerate(ue)}
    vi = {x: i for i, x in enumerate(ve)}

    # 正確な整数 2D 差分配列。スコアは、すべての開いたイベントセルで一定です。
    # NumPy は整数演算のみを実行します。
    diff = np.zeros((len(ue), len(ve)), dtype=np.int64)
    for u1, u2, v1, v2, w in rects:
        a, b = ui[u1], ui[u2]
        p, q = vi[v1], vi[v2]
        diff[a, p] += w
        diff[b, p] -= w
        diff[a, q] -= w
        diff[b, q] += w

    scores = diff.cumsum(axis=0).cumsum(axis=1)
    nu, nv = len(ue) - 1, len(ve) - 1

    best = 10**18
    for i in range(nu):
        u0, u1 = ue[i], ue[i + 1]
        if u1 <= u_dom_min or u0 >= u_dom_max:
            continue

        slab = clip_u(dom, u0, True)
        slab = clip_u(slab, u1, False)
        if not slab:
            continue

        vlo = min(v for _, v in slab)
        vhi = max(v for _, v in slab)
        if vhi <= vlo:
            continue

        # これは、実行可能なイベントセルのスーパーセットを調べる可能性があります。
        # これは下限値検証では保守的です。
        j0 = max(0, bisect_right(ve, vlo) - 1)
        j1 = min(nv - 1, bisect_left(ve, vhi) - 1)
        if j0 <= j1:
            row_min = int(scores[i, j0:j1 + 1].min())
            best = min(best, row_min)

    if best == 10**18:
        raise RuntimeError("center domain was not enumerated")
    return best


def angle_net() -> list[tuple[F, F]]:
    out: list[tuple[F, F]] = []
    for k in range(KMAX + 1):
        t = T * k / KMAX
        den = 1 + t * t
        c = (1 - t * t) / den
        s = 2 * t / den
        assert c * c + s * s == 1
        out.append((c, s))

    # 最後のペアは pi/4 をブラケットします。
    assert out[-2][1] < out[-2][0]
    assert out[-1][1] >= out[-1][0]

    # psi_k=2 arctan(t_k) の場合、隣接する角度ギャップの半分は
    # arctan(t_{k+1})-arctan(t_k) であり、そのタンジェントは
    # D/(1+t_k*t_{k+1}) <= D です。したがって、[0,pi/4] のすべての角度は
    # エラー epsilon < D の範囲内にあります。
    for k in range(KMAX):
        t0 = T * k / KMAX
        t1 = T * (k + 1) / KMAX
        tan_half_gap = (t1 - t0) / (1 + t0 * t1)
        assert tan_half_gap <= D

    return out


def main() -> None:
    atoms = build_atoms()
    total = sum(w for _, _, w in atoms)

    print(f"atoms = {len(atoms)}")
    print(
        f"total_weight = {total}/{WEIGHT_SCALE}"
        f" = {total / WEIGHT_SCALE:.4f}"
    )
    #assert len(atoms) == 268
    #assert total == 169476
    assert total < 17 * WEIGHT_SCALE

    net = angle_net()

    # 方向誤差 epsilon <= D の場合、
    # cos(epsilon)+sin(epsilon) <= 1+epsilon <= 1+D。
    contain = B * (1 + D)
    print(f"angle_net_size = {len(net)}")
    print(f"b*(1+d) = {contain} = {float(contain):.12f} < 1")
    assert contain < 1

    global_min = 10**18
    argmin = -1
    for k, (c, s) in enumerate(net):
        m = verify_orientation(c, s, atoms)
        if m < global_min:
            global_min, argmin = m, k
        if k % 30 == 0 or k == KMAX:
            print(
                f"orientation {k:3d}/{KMAX}: "
                f"min={m}/{WEIGHT_SCALE}, "
                f"global={global_min}/{WEIGHT_SCALE}"
            )

    print(
        f"minimum_score = {global_min}/{WEIGHT_SCALE}"
        f" = {global_min / WEIGHT_SCALE:.4f} at k={argmin}"
    )
    assert global_min >= WEIGHT_SCALE

    print("CERTIFICATE CONDITIONS VERIFIED.")
    print(f"By the scaling argument: s(17) >= {L} = {L:.4f}.")

    
if __name__ == "__main__":
    main()

画像を描画するためのプログラム

#lang racket

(require racket/list)
(require metapict)


{define-syntax-rule (for/append clauses body ...)
  ; Todo: Add support for #:breack and #:final
  (append* (for/list clauses (begin body ...)))}

{define (mirror-x N atoms)
  (for/append ([a (in-list atoms)])
    (match a
      [(list x y w)
       (list (list x y w) (list (- N 1 x) y w))]))}

{define (mirror-y N atoms)
  (for/append ([a (in-list atoms)])
    (match a
      [(list x y w)
       (list (list x y w) (list x (- N 1 y) w))]))}

{define (mirror-d atoms)
  (for/append ([a (in-list atoms)])
    (match a
      [(list x y w)
       (list (list x y w) (list y x w))]))}

{define-values (L-Green atoms-Green)
  (let () 
    ; Todo: Confirm these are the correct lengths.
    (define grid-nx 6)
    (define grid-ny 4)
    (define border-size-y (- (sqrt 2) 1/2))
    (define grid-size-y (/ (+ 12 (sqrt 8)) 17))
    (define border-size-x 1)
    (define L 
      (+ (* border-size-y 2) (* grid-size-y 3)))
    (define grid-size-x (/ (- L (* border-size-x 2)) 5))
    
    {define atoms/int '(#;() 
                        (0 3 1) (1 3 1) (3 3 1) (5 3 1)
                        (0 2 1) (2 2 1) (4 2 1) (5 2 1)
                        (0 1 1) (1 1 1) (3 1 1) (5 1 1)
                        (0 0 1) (2 0 1) (4 0 1) (5 0 1))}
    (define min-weight 1)

    {define atoms (for/list ([a (in-list atoms/int)])
                    (match a
                      [(list x y w)
                       (list (+ border-size-x (* grid-size-x x))
                             (+ border-size-y (* grid-size-y y))
                             (/ w min-weight))]))}
    (values L atoms)}

{define-values (L-Green/S atoms-Green/S)
  (let () 
    ; Todo: Confirm these are the correct lengths.
    (define grid-nx 6)
    (define grid-ny 4)
    (define border-size-y (- (sqrt 2) 1/2))
    (define grid-size-y (/ (+ 12 (sqrt 8)) 17))
    (define border-size-x 1)
    (define L 
      (+ (* border-size-y 2) (* grid-size-y (- grid-ny 1))))
    (define grid-size-x (/ (- L (* border-size-x 2)) (- grid-nx 1)))

    ; It's easier to calculate the overlaps by hand
    (define atoms/gen '(#;() 
                        (0 1 2) (1 1 1) (2 1 1)
                        (0 0 2) (1 0 1) (2 0 1)))
    (define min-weight 4)

    (define atoms/int (remove-duplicates
                       (mirror-x grid-nx
                                 (mirror-y grid-ny
                                           atoms/gen))))
    (define atoms/one-dir (for/list ([a (in-list atoms/int)])
                            (match a
                              [(list x y w)
                               (list (+ border-size-x (* grid-size-x x))
                                     (+ border-size-y (* grid-size-y y))
                                     (/ w min-weight))]))) 
    (define atoms (mirror-d atoms/one-dir))
    (values L atoms)}

{define-values (L-Burns atoms-Burns)
  (let () 
    (define grid-n 29)
    (define L 44811/10000)
    (define M 1)
    (define grid-size (/ (- L M) (- grid-n 1)))
    (define border-size (/ M 2))
    (define min-weight 10003)
    {define atoms/gen '(#;() 
                        (1 11 107) (2 4 137) (2 9 214) (2 11 107) (2 12 137)
                        (3 4 3884) (3 7 214) (3 8 913) (3 9 214)
                        (3 10 214) (3 11 1234) (3 12 2189) (3 14 384)
                        (4 4 1961) (4 7 520) (4 8 214) (4 9 1413) (4 10 1234)
                        (4 11 1083) (4 13 137) (4 14 292)
                        (7 11 529) (7 12 33) (8 10 906) (8 11 384) (8 12 351)
                        (9 9 340) (9 10 180) (9 11 204) (9 12 549)
                        (10 12 879) (10 13 201) (10 14 378)
                        (11 11 396) (11 12 622) (11 13 204) (11 14 204))}

    (define atoms/int (remove-duplicates
                       (mirror-x grid-n
                                 (mirror-y grid-n
                                           (mirror-d
                                            atoms/gen)))))

    (define atoms (for/list ([a (in-list atoms/int)])
                    (match a
                      [(list x y w)
                       (list (+ border-size (* grid-size x))
                             (+ border-size (* grid-size y))
                             (/ w min-weight))]))) 
    (values L atoms)}

{define-values (L-Massaccesi atoms-Massaccesi)
  (let () 
    (define grid-n 29)
    (define L 45058/10000)
    (define M 15513/10000)
    (define grid-size (/ (- L M) (- grid-n 1)))
    (define border-size (/ M 2))
    (define min-weight 576)
    {define atoms/gen '(#;() 
                        (0 2 165) (0 11 129) (1 8 36) (1 10 21) (1 11 15)
                        (2 2 246) (2 8 129) (2 9 105) (2 10 36) (2 11 105)
                        (5 10 36) (6 10 63) (6 11 12) (7 10 21)
                        (8 9 33) (8 11 15) (9 11 75) (9 14 39)
                        (10 11 25) (10 12 21) (10 13 24) (10 14 3) (11 11 16)}

    (define atoms/int (remove-duplicates
                       (mirror-x grid-n
                                 (mirror-y grid-n
                                           (mirror-d
                                            atoms/gen)))))

    (define atoms (for/list ([a (in-list atoms/int)])
                    (match a
                      [(list x y w)
                       (list (+ border-size (* grid-size x))
                             (+ border-size (* grid-size y))
                             (/ w min-weight))]))) 
    (values L atoms)}

{define (draw-example L atoms #:gamma [gamma 2.0] #:scale [scale 0.07])
  [with-window (window -.1 (+ L .1) -.1 (+ L .1))
    (define big-fill-color "whitesmoke")
    (define big-border-color "black")
    (define dots-color (change-alpha "darkred" 0.75))
    (define big-square (curve (pt 0 0) -- (pt 0 L) -- (pt L L) -- (pt L 0) -- cycle))
    (draw (color big-fill-color (fill big-square))
          (penscale .1 (color big-border-color (draw big-square)))
          (draw* (for/list ([a (in-list atoms)])
                   (match a
                     [(list x y w)
                      (define s (* (sqrt (expt w (/ 1. gamma))) scale)) 
                      (penstyle 'transparent (color dots-color (filldraw (circle (pt x y) s))))]))))]

(scale 4 (draw-example L-Green atoms-Green #:gamma 2.0 #:scale .07))

(scale 4 (draw-example L-Green/S atoms-Green/S #:gamma 2.0 #:scale .07))

(scale 4 (draw-example L-Burns atoms-Burns #:gamma 2.0 #:scale .07))

(scale 4 (draw-example L-Massaccesi atoms-Massaccesi #:gamma 2.0 #:scale .07))