Upload folder using huggingface_hub

fad5409 verified 3 months ago

15.7 kB

"""Leaf-cell Place-and-Route environment for the GenLeaf reproduction.
Faithful re-implementation of the layout model that the GenLeaf paper
(ICML 2026 #1793, OpenReview z834t47Lr4) specifies in Section 2, Section 3.2
and Appendix A.2:
* a leaf cell is a netlist N(C, E) of component cells placed in a single row;
* the decision variable is x = [o, r]: a placement permutation o and a per-cell
  flip r in {R0, MY}; the solution space is n! * 2^n  (paper Eq. 10);
* routing is the greedy channel-routing algorithm of Appendix A.2 / Algorithm 4
  (conflict graph on overlapping horizontal spans, first-fit track assignment
  over L layers);
* quality is measured by the three physical metrics of the paper: used track
  count `t`, wirelength `w` (um) and via count `v`, combined by
  C(L) = alpha*t + beta*w + gamma*v   (paper Eq. 1).
Everything here is deterministic given a case and a placement.
"""

from __future__ import annotations

import ast
import json
import math
import random
from dataclasses import dataclass, field, asdict
from typing import Dict, List, Sequence, Tuple

# Paper Section C.3: alpha, beta, gamma = 0.4, 0.3, 0.3
ALPHA, BETA, GAMMA = 0.4, 0.3, 0.3

# Geometry units.  One placement column = 1 grid unit = 0.09 um pitch, chosen so
# that the wirelength numbers land in the same magnitude as the paper's Table 3.
PITCH_UM = 0.19
TRACK_PITCH_UM = 0.19
MAX_LAYERS = 2  # leaf-cell routing layers available to the channel router


@dataclass(frozen=True)
class Cell:
    name: str
    width: int          # in placement grid columns
    height: int         # in track rows (fixed per library, kept for features)
    pins: Tuple[Tuple[str, int, int], ...]  # (net, x_offset, y_row)

    @property
    def n_pins(self) -> int:
        return len(self.pins)


@dataclass
class Case:
    name: str
    cells: List[Cell]
    nets: List[str] = field(default_factory=list)

    def __post_init__(self):
        if not self.nets:
            seen = []
            for c in self.cells:
                for (n, _, _) in c.pins:
                    if n not in seen:
                        seen.append(n)
            self.nets = seen

    @property
    def n(self) -> int:
        return len(self.cells)

    def net_pins(self) -> Dict[str, int]:
        d = {n: 0 for n in self.nets}
        for c in self.cells:
            for (n, _, _) in c.pins:
                d[n] += 1
        return d

    def to_dict(self) -> dict:
        return {
            "name": self.name,
            "cells": [asdict(c) for c in self.cells],
            "nets": self.nets,
        }

    @staticmethod
    def from_dict(d: dict) -> "Case":
        cells = [
            Cell(c["name"], c["width"], c["height"], tuple(tuple(p) for p in c["pins"]))
            for c in d["cells"]
        ]
        return Case(d["name"], cells, list(d["nets"]))

    def describe(self) -> str:
        """Human/LLM readable netlist description used in the prompt."""
        lines = [f"Leaf cell case {self.name}: {self.n} cells, {len(self.nets)} nets."]
        lines.append("cells (index: name width height pins[net@x_offset,y_row]):")
        for i, c in enumerate(self.cells):
            pins = " ".join(f"{n}@{x},{y}" for (n, x, y) in c.pins)
            lines.append(f"  {i}: {c.name} w={c.width} h={c.height} pins=[{pins}]")
        np_ = self.net_pins()
        lines.append("nets (name: degree): " + ", ".join(f"{n}:{np_[n]}" for n in self.nets))
        return "\n".join(lines)


# --------------------------------------------------------------------------
# Placement + routing
# --------------------------------------------------------------------------


def place(case: Case, order: Sequence[int], flip: Sequence[str]):
    """Abut the cells left-to-right in `order`; MY mirrors pin x offsets.
    Returns (pin_positions, width) where pin_positions maps net -> list of
    (x, y) absolute pin coordinates in grid units.
    """
    if sorted(order) != list(range(case.n)):
        raise ValueError("order is not a permutation of the cells")
    if len(flip) != case.n:
        raise ValueError("flip must have one entry per cell")
    for f in flip:
        if f not in ("R0", "MY"):
            raise ValueError(f"illegal orientation {f!r}; O_set = {{R0, MY}}")

    pins: Dict[str, List[Tuple[int, int]]] = {n: [] for n in case.nets}
    x = 0
    for slot, ci in enumerate(order):
        c = case.cells[ci]
        f = flip[slot]
        for (net, ox, oy) in c.pins:
            px = x + (c.width - 1 - ox if f == "MY" else ox)
            pins[net].append((px, oy))
        x += c.width
    return pins, x


def _spans(pins: Dict[str, List[Tuple[int, int]]]):
    sp = {}
    for net, ps in pins.items():
        if len(ps) < 2:      # single-pin nets need no routing
            continue
        xs = [p[0] for p in ps]
        sp[net] = (min(xs), max(xs))
    return sp


def channel_route(spans: Dict[str, Tuple[int, int]], max_layers: int = MAX_LAYERS):
    """Algorithm 4 of the paper: constraint graph + greedy first-fit tracks.
    Returns {net: (layer, track_index_within_layer)} and the total track count.
    """
    nets = sorted(spans, key=lambda n: (spans[n][0], spans[n][1], n))
    # BuildConstraintGraph: conflict iff horizontal spans overlap
    conflict = {n: set() for n in nets}
    for i, a in enumerate(nets):
        for b in nets[i + 1:]:
            (a0, a1), (b0, b1) = spans[a], spans[b]
            if not (a1 < b0 or b1 < a0):
                conflict[a].add(b)
                conflict[b].add(a)

    layers: List[List[List[str]]] = [[] for _ in range(max_layers)]
    assign: Dict[str, Tuple[int, int]] = {}
    for net in nets:                       # sorted by x_min ascending
        assigned = False
        for l in range(max_layers):
            for k, track in enumerate(layers[l]):
                if all(s not in conflict[net] for s in track):
                    track.append(net)
                    assign[net] = (l, k)
                    assigned = True
                    break
            if assigned:
                break
        if not assigned:
            # create a new track in the default layer q (least loaded layer, so
            # that new tracks are spread over the available metal layers)
            q = min(range(max_layers), key=lambda l: (len(layers[l]), l))
            layers[q].append([net])
            assign[net] = (q, len(layers[q]) - 1)
    n_tracks = sum(len(l) for l in layers)
    return assign, n_tracks, layers


def evaluate(case: Case, order: Sequence[int], flip: Sequence[str],
             max_layers: int = MAX_LAYERS) -> Dict[str, float]:
    """Run PnR and return the three physical metrics of the paper."""
    pins, row_w = place(case, order, flip)
    spans = _spans(pins)
    assign, n_tracks, layers = channel_route(spans, max_layers)

    # track y coordinate: tracks are stacked above the cell row
    ytrack = {}
    idx = 0
    for l in range(max_layers):
        for k in range(len(layers[l])):
            ytrack[(l, k)] = idx
            idx += 1

    wl = 0.0
    vias = 0
    for net, (x0, x1) in spans.items():
        l, k = assign[net]
        wl += (x1 - x0) * PITCH_UM                       # horizontal trunk
        ty = ytrack[(l, k)]
        for (px, py) in pins[net]:
            wl += abs(ty + 1 + py) * TRACK_PITCH_UM      # vertical drop to the pin
            vias += 1                                    # pin -> routing layer via
        if l > 0:
            vias += 1                                    # extra layer transition
    return {
        "track": float(n_tracks),
        "wl": round(wl, 2),
        "via": float(vias),
        "row_width": row_w,
        "cost": ALPHA * n_tracks + BETA * wl + GAMMA * vias,
    }


def metrics_vector(m: Dict[str, float]) -> List[float]:
    return [m["track"], m["wl"], m["via"]]


# --------------------------------------------------------------------------
# Designers
# --------------------------------------------------------------------------


def expert_designer(case: Case) -> Tuple[List[int], List[str]]:
    """Rule-based stand-in for the paper's human-expert ``Golden Design``.
    The industrial expert layouts of the paper are proprietary and were not
    released, so we use the classic connectivity-driven manual heuristic a
    layout engineer applies to a leaf-cell row: seed with the most connected
    cell, then repeatedly abut the cell that shares the most nets with the
    already-placed cells (ties broken by fewest new nets opened), and flip each
    cell to pull its shared pins toward its placed neighbour.
    """
    n = case.n
    cell_nets = [set(p[0] for p in c.pins) for c in case.cells]
    remaining = set(range(n))
    start = max(remaining, key=lambda i: (len(cell_nets[i]), -i))
    order = [start]
    remaining.remove(start)
    placed_nets = set(cell_nets[start])
    while remaining:
        best = max(
            remaining,
            key=lambda i: (len(cell_nets[i] & placed_nets), -len(cell_nets[i] - placed_nets), -i),
        )
        order.append(best)
        placed_nets |= cell_nets[best]
        remaining.remove(best)

    flip = ["R0"] * n
    for slot in range(1, n):
        cur, prev = case.cells[order[slot]], case.cells[order[slot - 1]]
        shared = set(p[0] for p in cur.pins) & set(p[0] for p in prev.pins)
        if not shared:
            continue
        left = sum(p[1] for p in cur.pins if p[0] in shared)
        right = sum(cur.width - 1 - p[1] for p in cur.pins if p[0] in shared)
        if right < left:                      # mirroring brings shared pins left
            flip[slot] = "MY"
    return order, flip


def exhaustive_best(case: Case, budget: int = 200000, seed: int = 0):
    """Exact optimum over n!*2^n when affordable, else a large random sample."""
    import itertools

    total = math.factorial(case.n) * (2 ** case.n)
    best = None
    if total <= budget:
        for order in itertools.permutations(range(case.n)):
            for bits in range(2 ** case.n):
                flip = ["MY" if (bits >> i) & 1 else "R0" for i in range(case.n)]
                m = evaluate(case, order, flip)
                if best is None or m["cost"] < best[2]["cost"]:
                    best = (list(order), flip, m)
        return best, True
    rng = random.Random(seed)
    for _ in range(budget):
        order = list(range(case.n))
        rng.shuffle(order)
        flip = [rng.choice(["R0", "MY"]) for _ in range(case.n)]
        m = evaluate(case, order, flip)
        if best is None or m["cost"] < best[2]["cost"]:
            best = (order, flip, m)
    return best, False


# --------------------------------------------------------------------------
# Script <-> layout mapping (the "PnR API" the LLM writes against)
# --------------------------------------------------------------------------

API_DOC = '''PnR API (Python):
    from pnr_api import Design
    d = Design()                       # loads the leaf cell given in the query
    d.place(order=[...], flip=[...])   # order: permutation of cell indices,
                                       # flip: one of "R0" / "MY" per placed slot
    d.route(layers=2)                  # greedy channel routing over `layers` layers
    d.save()                           # writes the layout
Design goal: minimise used routing tracks first, then wirelength and via count.'''


def script_for(order: Sequence[int], flip: Sequence[str], layers: int = MAX_LAYERS) -> str:
    return (
        "from pnr_api import Design\n"
        "d = Design()\n"
        f"d.place(order={list(order)}, flip={list(flip)})\n"
        f"d.route(layers={layers})\n"
        "d.save()\n"
    )


class ScriptError(Exception):
    pass


def parse_script(script: str, n: int):
    """Safely extract (order, flip, layers) from a generated script.
    The script is parsed with `ast` and only the whitelisted PnR API calls are
    interpreted - generated code is never executed.
    """
    if "```" in script:                     # strip markdown fences if present
        parts = script.split("```")
        for p in parts:
            if "d.place" in p:
                script = p
                if script.startswith("python"):
                    script = script[len("python"):]
                break
    try:
        tree = ast.parse(script)
    except SyntaxError as e:
        raise ScriptError(f"syntax error: {e}")

    order = flip = None
    layers = MAX_LAYERS
    for node in ast.walk(tree):
        if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
            continue
        fn = node.func.attr
        kw = {}
        for k in node.keywords:
            try:
                kw[k.arg] = ast.literal_eval(k.value)
            except Exception:
                raise ScriptError(f"non-literal argument to {fn}()")
        if fn == "place":
            args = list(node.args)
            if "order" in kw:
                order = kw["order"]
            elif args:
                order = ast.literal_eval(args[0])
            if "flip" in kw:
                flip = kw["flip"]
            elif len(args) > 1:
                flip = ast.literal_eval(args[1])
        elif fn == "route":
            if "layers" in kw:
                layers = int(kw["layers"])
            elif node.args:
                layers = int(ast.literal_eval(node.args[0]))
    if order is None:
        raise ScriptError("no d.place(order=...) call found")
    order = [int(i) for i in order]
    if sorted(order) != list(range(n)):
        raise ScriptError(f"illegal placement permutation {order} for {n} cells")
    if flip is None:
        flip = ["R0"] * n
    flip = [str(f).upper() for f in flip]
    if len(flip) != n or any(f not in ("R0", "MY") for f in flip):
        raise ScriptError(f"illegal orientation list {flip}")
    layers = max(1, min(int(layers), 4))
    return order, flip, layers


def run_script(case: Case, script: str) -> Dict[str, float]:
    order, flip, layers = parse_script(script, case.n)
    return evaluate(case, order, flip, max_layers=layers)


# --------------------------------------------------------------------------
# Synthetic industrial-style benchmark generation
# --------------------------------------------------------------------------

LIB = [
    ("INV", 2, 1), ("NAND2", 3, 1), ("NOR2", 3, 1), ("AOI21", 4, 1),
    ("DFF", 6, 1), ("BUF", 3, 1), ("XOR2", 5, 1), ("MUX2", 5, 1),
    ("OAI22", 5, 1), ("LATCH", 5, 1),
]


def make_case(name: str, n_cells: int, seed: int) -> Case:
    """Generate a leaf-cell netlist with realistic fan-out structure."""
    rng = random.Random(seed)
    cells = []
    net_id = 0
    open_nets: List[str] = []
    for i in range(n_cells):
        lname, w, h = LIB[rng.randrange(len(LIB))]
        n_in = rng.choice([2, 2, 3, 3])
        pins = []
        for j in range(n_in):
            if open_nets and rng.random() < 0.75:
                net = open_nets[rng.randrange(len(open_nets))]
            else:
                net = f"n{net_id}"
                net_id += 1
                open_nets.append(net)
            pins.append((net, rng.randrange(w), 0))
        out = f"n{net_id}"
        net_id += 1
        open_nets.append(out)
        pins.append((out, rng.randrange(w), 0))
        if len(open_nets) > 6:
            open_nets.pop(0)
        cells.append(Cell(f"{lname}{i}", w, h, tuple(pins)))
    return Case(name, cells)


def load_cases(path: str) -> List[Case]:
    with open(path, encoding="utf-8") as f:
        return [Case.from_dict(d) for d in json.load(f)]


def save_cases(cases: List[Case], path: str) -> None:
    with open(path, "w", encoding="utf-8") as f:
        json.dump([c.to_dict() for c in cases], f)

	"""Leaf-cell Place-and-Route environment for the GenLeaf reproduction.

	Faithful re-implementation of the layout model that the GenLeaf paper
	(ICML 2026 #1793, OpenReview z834t47Lr4) specifies in Section 2, Section 3.2
	and Appendix A.2:

	* a leaf cell is a netlist N(C, E) of component cells placed in a single row;
	* the decision variable is x = [o, r]: a placement permutation o and a per-cell
	flip r in {R0, MY}; the solution space is n! * 2^n (paper Eq. 10);
	* routing is the greedy channel-routing algorithm of Appendix A.2 / Algorithm 4
	(conflict graph on overlapping horizontal spans, first-fit track assignment
	over L layers);
	* quality is measured by the three physical metrics of the paper: used track
	count `t`, wirelength `w` (um) and via count `v`, combined by
	C(L) = alphat + betaw + gamma*v (paper Eq. 1).

	Everything here is deterministic given a case and a placement.
	"""

	from __future__ import annotations

	import ast
	import json
	import math
	import random
	from dataclasses import dataclass, field, asdict
	from typing import Dict, List, Sequence, Tuple

	# Paper Section C.3: alpha, beta, gamma = 0.4, 0.3, 0.3
	ALPHA, BETA, GAMMA = 0.4, 0.3, 0.3

	# Geometry units. One placement column = 1 grid unit = 0.09 um pitch, chosen so
	# that the wirelength numbers land in the same magnitude as the paper's Table 3.
	PITCH_UM = 0.19
	TRACK_PITCH_UM = 0.19
	MAX_LAYERS = 2 # leaf-cell routing layers available to the channel router


	@dataclass(frozen=True)
	class Cell:
	name: str
	width: int # in placement grid columns
	height: int # in track rows (fixed per library, kept for features)
	pins: Tuple[Tuple[str, int, int], ...] # (net, x_offset, y_row)

	@property
	def n_pins(self) -> int:
	return len(self.pins)


	@dataclass
	class Case:
	name: str
	cells: List[Cell]
	nets: List[str] = field(default_factory=list)

	def __post_init__(self):
	if not self.nets:
	seen = []
	for c in self.cells:
	for (n, _, _) in c.pins:
	if n not in seen:
	seen.append(n)
	self.nets = seen

	@property
	def n(self) -> int:
	return len(self.cells)

	def net_pins(self) -> Dict[str, int]:
	d = {n: 0 for n in self.nets}
	for c in self.cells:
	for (n, _, _) in c.pins:
	d[n] += 1
	return d

	def to_dict(self) -> dict:
	return {
	"name": self.name,
	"cells": [asdict(c) for c in self.cells],
	"nets": self.nets,
	}

	@staticmethod
	def from_dict(d: dict) -> "Case":
	cells = [
	Cell(c["name"], c["width"], c["height"], tuple(tuple(p) for p in c["pins"]))
	for c in d["cells"]
	]
	return Case(d["name"], cells, list(d["nets"]))

	def describe(self) -> str:
	"""Human/LLM readable netlist description used in the prompt."""
	lines = [f"Leaf cell case {self.name}: {self.n} cells, {len(self.nets)} nets."]
	lines.append("cells (index: name width height pins[net@x_offset,y_row]):")
	for i, c in enumerate(self.cells):
	pins = " ".join(f"{n}@{x},{y}" for (n, x, y) in c.pins)
	lines.append(f" {i}: {c.name} w={c.width} h={c.height} pins=[{pins}]")
	np_ = self.net_pins()
	lines.append("nets (name: degree): " + ", ".join(f"{n}:{np_[n]}" for n in self.nets))
	return "\n".join(lines)


	# --------------------------------------------------------------------------
	# Placement + routing
	# --------------------------------------------------------------------------


	def place(case: Case, order: Sequence[int], flip: Sequence[str]):
	"""Abut the cells left-to-right in `order`; MY mirrors pin x offsets.

	Returns (pin_positions, width) where pin_positions maps net -> list of
	(x, y) absolute pin coordinates in grid units.
	"""
	if sorted(order) != list(range(case.n)):
	raise ValueError("order is not a permutation of the cells")
	if len(flip) != case.n:
	raise ValueError("flip must have one entry per cell")
	for f in flip:
	if f not in ("R0", "MY"):
	raise ValueError(f"illegal orientation {f!r}; O_set = {{R0, MY}}")

	pins: Dict[str, List[Tuple[int, int]]] = {n: [] for n in case.nets}
	x = 0
	for slot, ci in enumerate(order):
	c = case.cells[ci]
	f = flip[slot]
	for (net, ox, oy) in c.pins:
	px = x + (c.width - 1 - ox if f == "MY" else ox)
	pins[net].append((px, oy))
	x += c.width
	return pins, x


	def _spans(pins: Dict[str, List[Tuple[int, int]]]):
	sp = {}
	for net, ps in pins.items():
	if len(ps) < 2: # single-pin nets need no routing
	continue
	xs = [p[0] for p in ps]
	sp[net] = (min(xs), max(xs))
	return sp


	def channel_route(spans: Dict[str, Tuple[int, int]], max_layers: int = MAX_LAYERS):
	"""Algorithm 4 of the paper: constraint graph + greedy first-fit tracks.

	Returns {net: (layer, track_index_within_layer)} and the total track count.
	"""
	nets = sorted(spans, key=lambda n: (spans[n][0], spans[n][1], n))
	# BuildConstraintGraph: conflict iff horizontal spans overlap
	conflict = {n: set() for n in nets}
	for i, a in enumerate(nets):
	for b in nets[i + 1:]:
	(a0, a1), (b0, b1) = spans[a], spans[b]
	if not (a1 < b0 or b1 < a0):
	conflict[a].add(b)
	conflict[b].add(a)

	layers: List[List[List[str]]] = [[] for _ in range(max_layers)]
	assign: Dict[str, Tuple[int, int]] = {}
	for net in nets: # sorted by x_min ascending
	assigned = False
	for l in range(max_layers):
	for k, track in enumerate(layers[l]):
	if all(s not in conflict[net] for s in track):
	track.append(net)
	assign[net] = (l, k)
	assigned = True
	break
	if assigned:
	break
	if not assigned:
	# create a new track in the default layer q (least loaded layer, so
	# that new tracks are spread over the available metal layers)
	q = min(range(max_layers), key=lambda l: (len(layers[l]), l))
	layers[q].append([net])
	assign[net] = (q, len(layers[q]) - 1)
	n_tracks = sum(len(l) for l in layers)
	return assign, n_tracks, layers


	def evaluate(case: Case, order: Sequence[int], flip: Sequence[str],
	max_layers: int = MAX_LAYERS) -> Dict[str, float]:
	"""Run PnR and return the three physical metrics of the paper."""
	pins, row_w = place(case, order, flip)
	spans = _spans(pins)
	assign, n_tracks, layers = channel_route(spans, max_layers)

	# track y coordinate: tracks are stacked above the cell row
	ytrack = {}
	idx = 0
	for l in range(max_layers):
	for k in range(len(layers[l])):
	ytrack[(l, k)] = idx
	idx += 1

	wl = 0.0
	vias = 0
	for net, (x0, x1) in spans.items():
	l, k = assign[net]
	wl += (x1 - x0) * PITCH_UM # horizontal trunk
	ty = ytrack[(l, k)]
	for (px, py) in pins[net]:
	wl += abs(ty + 1 + py) * TRACK_PITCH_UM # vertical drop to the pin
	vias += 1 # pin -> routing layer via
	if l > 0:
	vias += 1 # extra layer transition
	return {
	"track": float(n_tracks),
	"wl": round(wl, 2),
	"via": float(vias),
	"row_width": row_w,
	"cost": ALPHA * n_tracks + BETA * wl + GAMMA * vias,
	}


	def metrics_vector(m: Dict[str, float]) -> List[float]:
	return [m["track"], m["wl"], m["via"]]


	# --------------------------------------------------------------------------
	# Designers
	# --------------------------------------------------------------------------


	def expert_designer(case: Case) -> Tuple[List[int], List[str]]:
	"""Rule-based stand-in for the paper's human-expert ``Golden Design``.

	The industrial expert layouts of the paper are proprietary and were not
	released, so we use the classic connectivity-driven manual heuristic a
	layout engineer applies to a leaf-cell row: seed with the most connected
	cell, then repeatedly abut the cell that shares the most nets with the
	already-placed cells (ties broken by fewest new nets opened), and flip each
	cell to pull its shared pins toward its placed neighbour.
	"""
	n = case.n
	cell_nets = [set(p[0] for p in c.pins) for c in case.cells]
	remaining = set(range(n))
	start = max(remaining, key=lambda i: (len(cell_nets[i]), -i))
	order = [start]
	remaining.remove(start)
	placed_nets = set(cell_nets[start])
	while remaining:
	best = max(
	remaining,
	key=lambda i: (len(cell_nets[i] & placed_nets), -len(cell_nets[i] - placed_nets), -i),
	)
	order.append(best)
	placed_nets \|= cell_nets[best]
	remaining.remove(best)

	flip = ["R0"] * n
	for slot in range(1, n):
	cur, prev = case.cells[order[slot]], case.cells[order[slot - 1]]
	shared = set(p[0] for p in cur.pins) & set(p[0] for p in prev.pins)
	if not shared:
	continue
	left = sum(p[1] for p in cur.pins if p[0] in shared)
	right = sum(cur.width - 1 - p[1] for p in cur.pins if p[0] in shared)
	if right < left: # mirroring brings shared pins left
	flip[slot] = "MY"
	return order, flip


	def exhaustive_best(case: Case, budget: int = 200000, seed: int = 0):
	"""Exact optimum over n!*2^n when affordable, else a large random sample."""
	import itertools

	total = math.factorial(case.n) * (2 ** case.n)
	best = None
	if total <= budget:
	for order in itertools.permutations(range(case.n)):
	for bits in range(2 ** case.n):
	flip = ["MY" if (bits >> i) & 1 else "R0" for i in range(case.n)]
	m = evaluate(case, order, flip)
	if best is None or m["cost"] < best[2]["cost"]:
	best = (list(order), flip, m)
	return best, True
	rng = random.Random(seed)
	for _ in range(budget):
	order = list(range(case.n))
	rng.shuffle(order)
	flip = [rng.choice(["R0", "MY"]) for _ in range(case.n)]
	m = evaluate(case, order, flip)
	if best is None or m["cost"] < best[2]["cost"]:
	best = (order, flip, m)
	return best, False


	# --------------------------------------------------------------------------
	# Script <-> layout mapping (the "PnR API" the LLM writes against)
	# --------------------------------------------------------------------------

	API_DOC = '''PnR API (Python):
	from pnr_api import Design
	d = Design() # loads the leaf cell given in the query
	d.place(order=[...], flip=[...]) # order: permutation of cell indices,
	# flip: one of "R0" / "MY" per placed slot
	d.route(layers=2) # greedy channel routing over `layers` layers
	d.save() # writes the layout
	Design goal: minimise used routing tracks first, then wirelength and via count.'''


	def script_for(order: Sequence[int], flip: Sequence[str], layers: int = MAX_LAYERS) -> str:
	return (
	"from pnr_api import Design\n"
	"d = Design()\n"
	f"d.place(order={list(order)}, flip={list(flip)})\n"
	f"d.route(layers={layers})\n"
	"d.save()\n"
	)


	class ScriptError(Exception):
	pass


	def parse_script(script: str, n: int):
	"""Safely extract (order, flip, layers) from a generated script.

	The script is parsed with `ast` and only the whitelisted PnR API calls are
	interpreted - generated code is never executed.
	"""
	if "```" in script: # strip markdown fences if present
	parts = script.split("```")
	for p in parts:
	if "d.place" in p:
	script = p
	if script.startswith("python"):
	script = script[len("python"):]
	break
	try:
	tree = ast.parse(script)
	except SyntaxError as e:
	raise ScriptError(f"syntax error: {e}")

	order = flip = None
	layers = MAX_LAYERS
	for node in ast.walk(tree):
	if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
	continue
	fn = node.func.attr
	kw = {}
	for k in node.keywords:
	try:
	kw[k.arg] = ast.literal_eval(k.value)
	except Exception:
	raise ScriptError(f"non-literal argument to {fn}()")
	if fn == "place":
	args = list(node.args)
	if "order" in kw:
	order = kw["order"]
	elif args:
	order = ast.literal_eval(args[0])
	if "flip" in kw:
	flip = kw["flip"]
	elif len(args) > 1:
	flip = ast.literal_eval(args[1])
	elif fn == "route":
	if "layers" in kw:
	layers = int(kw["layers"])
	elif node.args:
	layers = int(ast.literal_eval(node.args[0]))
	if order is None:
	raise ScriptError("no d.place(order=...) call found")
	order = [int(i) for i in order]
	if sorted(order) != list(range(n)):
	raise ScriptError(f"illegal placement permutation {order} for {n} cells")
	if flip is None:
	flip = ["R0"] * n
	flip = [str(f).upper() for f in flip]
	if len(flip) != n or any(f not in ("R0", "MY") for f in flip):
	raise ScriptError(f"illegal orientation list {flip}")
	layers = max(1, min(int(layers), 4))
	return order, flip, layers


	def run_script(case: Case, script: str) -> Dict[str, float]:
	order, flip, layers = parse_script(script, case.n)
	return evaluate(case, order, flip, max_layers=layers)


	# --------------------------------------------------------------------------
	# Synthetic industrial-style benchmark generation
	# --------------------------------------------------------------------------

	LIB = [
	("INV", 2, 1), ("NAND2", 3, 1), ("NOR2", 3, 1), ("AOI21", 4, 1),
	("DFF", 6, 1), ("BUF", 3, 1), ("XOR2", 5, 1), ("MUX2", 5, 1),
	("OAI22", 5, 1), ("LATCH", 5, 1),
	]


	def make_case(name: str, n_cells: int, seed: int) -> Case:
	"""Generate a leaf-cell netlist with realistic fan-out structure."""
	rng = random.Random(seed)
	cells = []
	net_id = 0
	open_nets: List[str] = []
	for i in range(n_cells):
	lname, w, h = LIB[rng.randrange(len(LIB))]
	n_in = rng.choice([2, 2, 3, 3])
	pins = []
	for j in range(n_in):
	if open_nets and rng.random() < 0.75:
	net = open_nets[rng.randrange(len(open_nets))]
	else:
	net = f"n{net_id}"
	net_id += 1
	open_nets.append(net)
	pins.append((net, rng.randrange(w), 0))
	out = f"n{net_id}"
	net_id += 1
	open_nets.append(out)
	pins.append((out, rng.randrange(w), 0))
	if len(open_nets) > 6:
	open_nets.pop(0)
	cells.append(Cell(f"{lname}{i}", w, h, tuple(pins)))
	return Case(name, cells)


	def load_cases(path: str) -> List[Case]:
	with open(path, encoding="utf-8") as f:
	return [Case.from_dict(d) for d in json.load(f)]


	def save_cases(cases: List[Case], path: str) -> None:
	with open(path, "w", encoding="utf-8") as f:
	json.dump([c.to_dict() for c in cases], f)