acceptodds
Under review as a conference paper at ICLR 2027

Manhattan Assembly: Differentiable Mask Optimization with Manhattan Primitives

Abstract

Inverse Lithography Technology (ILT) formulates mask optimization as an inverse-design problem subject to manufacturing constraints, yet existing methods struggle to jointly balance printing fidelity, manufacturability, and scale. We present , a primitive-based framework that represents photomasks as axis-aligned rectangular primitives and optimizes their continuous geometry through a differentiable renderer while preserving Manhattan structure by construction. A lithography-guided adaptive refinement strategy adjusts primitive allocation through splitting and pruning, concentrating representation capacity in critical hotspot regions, while global primitive sharing with window-wise computation enables full-chip optimization. Experiments on ICCAD13-S and full-chip layouts from real chip designs demonstrate improved printing fidelity and process-window robustness with reduced mask complexity. In the full-chip setting, Manhattan Assembly reduces and PVB by 34.2% and 9.1%, respectively, relative to the best SOTA baseline for each metric.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Mask Optimization, Primitive-Based Representations, Inverse Lithography

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_3zAuOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper raised a very interesting Lithographic Mask Optimization; this method applies differentiable Manhattan Primitive Representation and combined with adaptive splitting and pruning mechanism. The experiment results show in different layout scales can get good performance of printing fidelity and mask complexity. Main contribution includes:

  1. Differentiable Rectangle Renderer: Support continuous optimization of rectangle parameters and preserve Manhattan geometry simultaneously.
  2. Lithography-Guided Adaptive Refinement: Split and prune primitives based on printing loss.
  3. Globally Shared Primitive Representation: Supports window-wise optimization for full-chip layouts while maintaining cross-window consistency. On ICCAD13 and CHIP-L benchmarks, the raised method performs well on L2 loss, edge placement error, process variation band, and mask complexity. In full-chip experiments, L2 and PVB decrease 34.2% and 9.1% correspond to best baseline respectively. Mask rule checking and ablation studies also shows this raised method works.
Critical strengths
  1. Differentiable Rectangle Renderer: The splitting criterion based on gradient discrepancy can identify local optimization needs that are obscured by gradient cancellation. This supports continuous optimization of rectangle parameters and preserves Manhattan geometry simultaneously.
  2. Strong empirical results across multiple scales. Mask rule checking and ablation studies also shows this raised method works.
Critical weaknesses
  1. Relatively high computational cost: According to experiment results, runtime of this Manhattan method (7427.01s) is obviously longer than some baselines, especially the learning-based methods (87.43s). I understand performance of printing fidelity and mask complexity performs very good, but I am concerned that the extra computation cost might restrict this method’s application. Author should clarify the trade-off here, help reader evaluate practical application value comprehensively.
  2. Geometric constraints are satisfied by how: I understand authors mentioned minimum width/spacing/notch size and so on constrain, but the details implementation is still limited. Especially primitive parameters continuous updates and splitting and pruning operations. More than that, I am also wondering how authors ensure the whole resulting geometry can satisfy corresponding mask design rules.
Questions for authors
  1. Constraint Guarantee: After continuous updates, splits, and pruning, does the design rule for rectangular unions still provide strict guarantees, or is it verified only through post‑hoc MRC checks?
  2. Splitting criterion: What is the fundamental difference between the gradient‑difference criterion and the existing gradient‑based adaptive refinement? Does Figure 7(b) constrain the final number of primitives and the computational cost to ensure a fair comparison?
  3. Experimental fairness: In CHIP-L, do the retrained learning-based baselines properly separate the training and test sets according to the original design, thereby preventing data leakage? Are the lithography settings and manufacturability requirements consistent across all methods?
2 comments
AuthorsOpenReview ↗

Rebuttal (1/2)

Q1/W2: Constraint guarantees across updates, splits and pruning

We enforce the specified geometric rules during optimization. The final mask-rule check (MRC) verifies compliance; it does not repair the mask.

Rules on primitives and the assembled mask. We impose a 20 nm minimum on each rectangle's width and height. On the assembled union, we check a minimum junction width of 20 nm, a minimum spacing of 20 nm between disconnected features, and a minimum notch size of 10 nm. We also check offsets between parallel exposed edges separately: the edges may align, but a nonzero step must be at least 20 nm. End faces with two convex corners follow the width rule, whereas trench bottoms with two concave corners are subject only to the 10 nm notch rule. These checks are expressed as differences between edge coordinates (§3.3, L251–260; Supplementary §D, L216–229).

Enforcement during optimization. After a continuous update, we project violating coordinate differences to their nearest feasible values, recompute the exposed contour and connected components, and repeat projection and checking until all rules are satisfied. This rechecking is necessary because changing one coordinate can affect several constraints. A split preserves the union and is accepted only if both children meet the primitive size bounds and the assembled mask satisfies the rules. Subsequent independent updates undergo the same contour checks. A pruning step is accepted only if the remaining union satisfies the geometric rules. Thus, the guarantee applies to the specified checks on accepted states, and the final mask requires no separate geometric repair.

Verification. Figure 6 reports zero width, spacing, and notch violations on ICCAD13-S and ICCAD13-L. On ICCAD13-S, we also observed no edges or jogs shorter than 20 nm, with a minimum measured edge length of 20.1 nm. The absence of trench bottoms in the 10–20 nm range is an empirical result, not an additional constraint. Without geometric constraints, the corresponding averages were 735.1 short edges and 582.4 short jogs per case (see our response to wYhP Q2/W2). The rules and update procedure are provided in Supplementary Section D and Algorithm 1.

AuthorsOpenReview ↗

Rebuttal (2/2)

Q2/W1: Splitting, fairness and runtime

Q2 — What the splitting criterion measures. Existing gradient-based adaptive refinement, such as densification in 3DGS, ranks primitives by the magnitude of their own positional gradient; the parent-gradient (Grad.) baseline in Fig. 7(b) follows this rule. Parent-gradient ranking measures the sensitivity of the loss to a shared update of the primitive. Our criterion measures the sensitivity to a differential update that a split would enable. A temporary bisection leaves the mask unchanged, and the new internal interface contributes no boundary gradient under our backward convention (§3.2, L234–237). In the coordinates selected in Eq. (5), g₁+g₂ gives the gradient for updating the children together, while g₁−g₂ gives the gradient for updating them differentially. When two parts of an edge need to move in opposite directions, the shared gradient can be small even though the differential gradient is large, so a parent-gradient criterion can overlook primitives that need finer control. The ratio in Eq. (6) uses these signals to determine when to refine.

Q2 — Comparison controls in Fig. 7(b). Fig. 7(b) controls the refinement budget rather than the final primitive count or runtime. All variants start with 500 primitives, run for 500 iterations, and use the same split and prune schedule and per-round caps (24 split candidates and 12 accepted removals; Supplementary Table 1 and Algorithm 1). The comparison varies only how split candidates are prioritized (§4.4, L484–490). Each variant therefore has the same opportunity to split and prune, while the realized final primitive counts can differ as a result of the selected splits. Child-gradient scoring reuses the existing lithography gradient and requires no additional lithography simulation; on ICCAD13-S, splitting and scoring take about 61 ms per case out of the 9.73 s mean TAT (PLY3 W4). Under these controls, discrepancy-based ranking achieves 1.90 nm EPE and 257.9 shots, compared with 2.38 nm and 362.1 shots for parent-gradient ranking and 2.40 nm and 385.2 shots for random ranking. Thus, the gain comes from which primitives are split under the same budget, not from a larger refinement allowance.

W1 — Full-chip runtime. On CHIP-L3, Manhattan Assembly takes 7,427.01 s (2.06 h) per layout, compared with 86.43 s for LVM-MO. This is a substantial cost for the gains in printing fidelity and mask complexity. Our TAT includes per-layout optimization, refinement, and the in-loop geometric checks described in Q1. LVM-MO's TAT measures inference and excludes training. Both learned baselines were retrained for CHIP-L (§4.2), while Manhattan Assembly requires no training data. Our response to wYhP Q4/Q5 and Supplementary Fig. 4 report the quality–runtime trade-off on ICCAD13-S. The revised manuscript clarifies the timing scope in §4.1 (L362–366) and the refinement controls in §4.4 (L484–490), with schedules and caps in Supplementary Table 1 and Algorithm 1.

Q3: Train/test separation and evaluation fairness

Train/test separation. Yes. We split the data by original RTL design: training and test layouts were generated from disjoint sets of RTL designs. As described in §4.2 (L424–427), we retrained TokMan and LVM-MO using their original configurations and evaluated them on the held-out CHIP-L cases. The ten CHIP-L3 layouts and their CHIP-L1 and CHIP-L2 crops were held out together; neither the test layouts nor any windows extracted from them were used for training.

Common evaluation. We evaluate all final CHIP-L masks using the same lithography simulator and process parameters (§4.1) and the same implementations of L₂, PVB, EPE, and shot count (Supplementary B). Shot counts are computed by applying the same greedy rectangular decomposition to each final binary mask, independently of the number of primitives used during optimization. For the mask-rule comparison, we apply the same thresholds to all masks in that comparison: 20 nm minimum width, 20 nm minimum spacing, and 10 nm minimum notch size (Supplementary Table 1).

Reviewer_wYhPOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper addresses inverse lithography technology (ILT), which optimizes photomasks to improve printing fidelity while satisfying manufacturing constraints. The authors argue that existing methods struggle to balance printing fidelity, manufacturability, and scalability. To address this challenge, they propose Manhattan Assembly. Experiments on ICCAD13-S and full-chip layouts derived from real chip designs demonstrate the effectiveness of the proposed approach.

Critical strengths
  1. The framework tackles an important problem.

  2. The experimental results shows strong performance.

  3. This paper is easy to follow. I like the presenting part of this paper (e.g., Figure 1). Good job.

  4. The figures are nicely crafted.

Critical weaknesses

1. Comparison with related primitive-based optimization methods

The proposed Manhattan Assembly framework shares notable methodological similarities with existing primitive-based mask optimization approaches, such as CircleOpt (DAC 2024) and Shot Splatting (IEEE TCAD 2026), which also explore explicit geometric representations and direct optimization of primitive parameters. While Manhattan Assembly introduces Manhattan-constrained rectangular primitives and adaptive refinement mechanisms, its relationship to these closely related approaches is not discussed in the Related Work section. A more detailed comparison would help clarify how the proposed method extends existing primitive-based optimization frameworks and better distinguish its specific technical contributions.

2. Incomplete evaluation of mask geometric complexity and manufacturability

Although the authors report shot count and zero MRC violations for minimum width, spacing, and notch constraints, these metrics may not fully characterize local boundary irregularities such as short edges and tiny jogs. Primitive splitting itself preserves the mask geometry, but subsequent independent updates of the child primitives may introduce such features. The reported MRC checks do not explicitly address minimum edge-length or jog-length constraints. Please clarify whether these constraints are relevant to the target manufacturing process and, if so, whether they are enforced. Additional geometric statistics on short edges and tiny jogs would help assess mask complexity beyond shot count.

3. Fairness of the full-chip baseline comparison

DiffOPC produces fewer shots than Manhattan Assembly on ICCAD13, but substantially more under the divide-and-conquer setup on CHIP-L. Although Figure 7(c) supports the benefit of global primitive sharing, it remains unclear whether the partitioning setup used for the baselines is sufficiently tuned. Please clarify how the tile sizes, overlaps, and stitching procedures were selected for DiffOPC and TokMan, and whether alternative settings could reduce their shot counts. This would help assess whether the reported advantage is partly due to the baseline implementation.

4. Quality–runtime trade-off

Section 4.2 acknowledges that Manhattan Assembly trades additional runtime for higher fidelity. However, the final results do not show how solution quality changes with the computational budget, particularly relative to faster baselines such as LVM-MO. Please quantify this trade-off by varying the number of optimization iterations and the initial primitive count. Quality-versus-runtime curves would help clarify when the additional optimization time provides a worthwhile improvement and whether the method can accommodate different runtime requirements.

5. Primitive initialization and SRAF-like structures

For ICCAD13, the main text specifies 500 initial rectangular primitives with uniformly spaced centers, but does not state their initial widths and heights. Please provide these settings or a precise reference to the supplementary material. In addition, Figure 5 appears to show SRAF-like structures near the main features, but this observation is not discussed in the manuscript. Could the authors comment on these structures and explain how they emerge during optimization?

6. Relationship between gradient discrepancy and lithographic hotspots

The proposed splitting criterion measures gradient discrepancies between child primitives, which primarily reflect differences in local geometric correction demands rather than the severity of lithographic hotspots. While the experimental results demonstrate the effectiveness of this criterion, its relationship to the claimed concentration of refinement in critical hotspot regions could be further clarified.

7. Novelty

The framework combines primitive-based optimization, adaptive refinement, and global parameter sharing, but its methodological advances over related approaches are not clearly distinguished. A more explicit comparison is needed to assess the originality of the proposed components.

Questions for authors
  1. How does Manhattan Assembly differ from CircleOpt and Shot Splatting? Which components constitute the main methodological advances?

  2. Are minimum edge-length and jog-length constraints relevant to the target manufacturing process? If so, how are they enforced and evaluated on the assembled mask?

  3. How were tile sizes, overlaps, and stitching procedures selected for DiffOPC and TokMan on CHIP-L? How sensitive are their fidelity and shot counts to these settings?

  4. How do printing quality and shot count change with runtime, iteration budget, and initial primitive count? Can the authors provide quality–runtime curves and matched-budget comparisons where applicable?

  5. What are the initial widths and heights of the rectangular primitives on ICCAD13? Are the complete initialization settings provided in the supplementary material?

  6. Novelty.

3 comments
AuthorsOpenReview ↗

Rebuttal (1/3)

Q1/Q6/W1/W7: Relationship with CircleOpt and Shot Splatting; Novelty

We thank the reviewer for pointing us to these closely related methods, and we have added them to the Related Work (§2, L120–130). Our method shares certain similarities with CircleOpt and Shot Splatting. However, both approaches focus on the writing shots of e-beam mask writers and aim to jointly optimize shots with OPC or MPC. They start from an existing pixel-based mask, fit it with shots of different shapes, and then refine it. Any SRAFs therefore come from the initial pixel-based solution and cannot be freely generated or removed during shot optimization.

In contrast, on ICCAD13, our method starts from uniformly initialized rectangular primitives and progressively adjusts their positions and sizes under the wafer printing loss. On CHIP-L, initialization instead uses a rectangular decomposition of the target layout (§4.1, L330–335). Together with splitting and pruning, it generates both main patterns and SRAFs within the same optimization space, giving it a degree of freedom close to that of pixel-based methods. At the same time, every accepted state satisfies the specified Manhattan and MRC checks, so the mask remains MRC-clean throughout optimization. Since optical proximity effects have a large interaction range and strongly affect the mask in OPC, we expect such a combination of optimization freedom and manufacturability to be well suited to this task. Three components support this:

  1. Differentiable rectangle renderer. Manhattan Assembly maps the primitive composition to a pixel-domain mask through a differentiable rectangle renderer, so primitive geometry is optimized directly against wafer-domain printing objectives rather than fitted to an existing pixel mask. The renderer computes exact union coverage with analytic gradients on exposed edges (PLY3 Q2/W2), and bisecting a rectangle leaves the mask and wafer loss unchanged, which lets us test candidate splits before changing the mask.

  2. Adaptive refinement. Splits are selected by the discrepancy between child gradients, and primitives whose removal has little effect on the printing loss are pruned. On ICCAD13-S, splitting and pruning reduce EPE from 2.35 to 1.90 nm relative to a fixed primitive set, with 257.9 shots (Fig. 7(a)). Under the same refinement schedule and candidate caps, discrepancy-based selection also improves on parent-gradient ranking in EPE (2.38 to 1.90 nm) and shots (362.1 to 257.9; Fig. 7(b), PLY3 W3). SRAF-like features arise in the same optimization without a separate insertion step (Fig. 5; see Q5 below).

  3. Global sharing. Rendering and simulation are local, but gradients accumulate into shared primitive parameters, so a feature spanning several windows remains one geometric object. On CHIP-L1, this reduces EPE from 11.32 to 3.13 nm and shots from 3,679.5 to 1,687.8 relative to independent window optimization (Fig. 7(c); tiling protocol: see Q3 below).

We have added these comparisons to the Related Work.

Q2/W2 — Short edges and jogs

We explicitly check both jog lengths and exposed edge lengths on the assembled mask contour during optimization. For jogs, we check the offset δ between adjacent parallel contour segments separately from the junction width. The segments must either align (δ=0) or form a jog of at least 20 nm (δ≥20 nm). We also check the length of every exposed contour edge against the applicable minimum-length rule. End faces with two convex corners follow the 20 nm width rule, whereas trench bottoms with two concave corners are subject only to the 10 nm notch rule (§3.3, L251–260; Supplementary §D, L216–229).

Splitting preserves the assembled contour, but subsequent independent updates of the child rectangles can introduce short edges or jogs. When an update violates a rule, we adjust the relevant rectangle edge coordinates, recompute the union contour, and check it again. Pruning is accepted only if the resulting contour passes the same checks.

We measured edge and jog lengths on the final assembled masks for all ten ICCAD13-S layouts, using a 20 nm cutoff for both measurements.

SettingMinimum edge length (nm)Edges <20 nm per caseJogs <20 nm per case
Without geometric constraints1.0735.1582.4
With geometric constraints20.100

With the geometric constraints enabled, none of the ten masks contained an edge or jog shorter than 20 nm. In particular, the absence of trench bottoms in the 10–20 nm range is an empirical observation, not an additional constraint. We have clarified the contour checks in the manuscript and reported these statistics in Supplementary Table 5.

AuthorsOpenReview ↗

Rebuttal (2/3)

Q3/W3: Tiling sensitivity and baseline fairness

Table 2 uses the tiling configuration that achieved the lowest EPE and shot count for both DiffOPC and TokMan in our CHIP-L1 sweep. We use 2048×2048-pixel tiles with a 256-pixel overlap (stride 1792), place the binary tile masks in global coordinates, and stitch them at the midpoint of each overlap. We then run 50 local optimization steps in a band extending 64 pixels to either side of each seam, using lithography simulation of the full layout to provide context across the seam.

We varied tile size, overlap, and seam refinement on the ten 4096×4096-pixel CHIP-L1 layouts. ★ marks the configuration reported in Table 2. EPE is in nm.

Tile (px)Overlap (px)Seam refineDiffOPC L2 ↓DiffOPC EPE ↓DiffOPC Shots ↓TokMan L2 ↓TokMan EPE ↓TokMan Shots ↓
1024128Yes669,66311.4012,620.8576,80610.834,886.9
1536128Yes665,86510.3912,394.2581,9519.734,790.6
2048128Yes594,2319.0110,538.9563,7916.214,618.6
20480Yes635,6408.7613,668.8537,9997.424,354.3
204864Yes601,5718.6512,027.5479,5996.294,413.6
2048 ★256 ★Yes ★573,0058.569,571.7485,1015.213,564.5
2048128No709,23514.6413,184.9632,08712.725,492.0
2048256No693,71312.6213,181.2629,35211.445,379.6
Ours——183,5843.131,687.8183,5843.131,687.8

At the selected tile size and overlap, seam refinement reduces EPE from 12.62 to 8.56 nm for DiffOPC and from 11.44 to 5.21 nm for TokMan, while also reducing shot counts. Larger tiles improve EPE and shot count at a fixed 128-pixel overlap. The effect of overlap varies by metric: TokMan achieves a slightly lower L₂ with 64 pixels of overlap, whereas the 256-pixel setting gives both baselines their best EPE and shot count. On the same CHIP-L1 layouts, Manhattan Assembly achieves L₂=183,584, EPE of 3.13 nm, and 1,687.8 shots, improving on both baselines across all tested configurations. Thus, tuning the tiling and refining the seams improve both baselines substantially, but do not close the gap on CHIP-L1.

AuthorsOpenReview ↗

Rebuttal (3/3)

Q4/Q5/W4/W5: Initialization and quality-runtime tradeoffs

Q4 — Quality versus runtime. On ICCAD13-S, we vary either the initial primitive count N₀ or the iteration budget B, holding the other fixed. For each B, we proportionally rescale the three optimization stages and the split and prune check times, keeping the scheduled number of checks fixed. Other settings follow the main text.

N₀BL2 ↓PVB ↓EPE (nm) ↓Shots ↓TAT (s)
25050026,22449,6853.97317.65.38
50050019,84944,2001.90257.99.73
75050023,08645,5622.99944.112.23
100050023,99446,0523.121,279.916.91
50025023,17250,4412.96655.96.74
500100022,16050,2282.79603.211.51
500200021,64045,1862.48574.617.90

The default gives the lowest L₂, PVB, EPE, and shot count among the tested settings. Reducing the iteration budget from 500 to 250 lowers mean runtime from 9.73 to 6.74 s, while EPE rises from 1.90 to 2.96 nm and shot count increases from 257.9 to 655.9. Starting with more rectangles or using longer schedules also increases runtime without improving on the default. Separately, the runtime trace for S01 in Supplementary Fig. 4 shows EPE falling to about 3 nm within 0.5 s, with shot count subsequently fluctuating between roughly 285 and 330. This trace illustrates the potential for early stopping on one case; the table compares separately scheduled runs. Both analyses characterize Manhattan Assembly on ICCAD13-S; a matched-runtime comparison with LVM-MO at full-chip scale remains open.

Q5 — Initialization and SRAF-like features. On ICCAD13, we initialize 500 rectangles of 100 nm × 100 nm (half-width and half-height of 50 nm) with centers on a uniform grid, and optimize them for 500 iterations (§4.1, L330–333; Supplementary Table 1). For CHIP-L, including the full-chip examples in Fig. 5, initialization instead uses a rectangular decomposition of the target layout (L333–335; Supplementary §A, L42–46).

The SRAF-like structures in Fig. 5 emerge from the same optimization that corrects the main patterns. The optimizer adjusts the positions and sizes of rectangles using the wafer printing loss, and splitting and pruning change which rectangles are available for local corrections. Small auxiliary structures can thus emerge near the main features without a separate assist-feature insertion step. They remain Manhattan and are subject to the same geometric checks as the rest of the mask.

W6: Gradient discrepancy versus hotspots

We agree that m^diff does not measure hotspot severity. It estimates whether a candidate split would enable a useful local update. As discussed in §3.4, temporary bisection preserves the current mask and printing loss. In the selected coordinates, g₁+g₂ is the gradient for updating both children together, while g₁−g₂ is the gradient for updating them differentially. For example, if two parts of an edge need to move in opposite directions, the shared gradient can be small even though the differential update is useful. Under the same refinement schedule and candidate caps, discrepancy-based selection yields lower EPE and fewer shots than parent-gradient ranking in Fig. 7(b).

The two signals need not coincide. A severe hotspot may be corrected by moving or resizing an existing primitive, while a region with a smaller printing error may still benefit from independent updates. Pruning separately tests whether a primitive can be removed with little effect on printing loss (Eq. 7). The revised §3.4 (L269–282) clarifies that the criterion allocates flexibility according to local correction demands; it does not explicitly target hotspots.

In the examples examined, we observe splits near lithographic hotspots, where independent updates help accommodate different local correction demands. This is an empirical observation; the splitting criterion itself does not use hotspot labels or measure hotspot severity.

Reviewer_PLY3OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Manhattan Assembly, a differentiable mask optimization framework that represents photomasks using axis-aligned rectangular primitives. The method combines differentiable rectangle rendering with lithography-guided adaptive splitting and pruning to improve printing fidelity while preserving Manhattan geometry. A global primitive-sharing strategy is introduced to further support full-chip optimization. Experiments on ICCAD13 and CHIP-L demonstrate improvements in printing accuracy and mask complexity when compared with existing methods.

Critical strengths
  1. The paper proposed a novel differentiable formulation for mask optimization to preserve Manhattan shapes.
  2. The splitting and pruning strategy offers an intuitive approach to adjusting geometric flexibility based on lithography simulation feedback.
  3. Global primitive sharing enables full-chip optimization while mitigating boundary inconsistencies between computational windows.
  4. Experimental results demonstrate promising improvements in critical evaluation metrics.
Critical weaknesses
  1. The main claim of the paper is that Manhattan Assembly can enhance optimization flexibility. It would be great to see the separate comparison with baselines in hotspot and non-hotspot regions.
  2. The paper did not explain how the exposed edge lengths are computed when multiple rectangles overlap.
  3. Section 3.4 attributes optimization plateaus to gradient cancellation between different parts of a primitive. This is an intuitive explanation, but it has not been sufficiently validated.
  4. Please discuss the time complexity analysis of temporary splitting, gradient evaluation, and loss-based pruning.
Questions for authors
  1. Can the authors please provide separate L2 and EPE comparisons for hotspot and non-hotspot regions, along with visualizations of primitive allocation before and after refinement?
  2. How are gradients defined and assigned at non-differentiable configurations, particularly when rectangles share boundaries?
2 comments
AuthorsOpenReview ↗

Rebuttal (1/2)

Q1/W1 — Hotspot and non-hotspot evaluation

Thank you for suggesting this regional comparison. We evaluate all methods on the same hotspot and non-hotspot windows from CHIP-L1 and report L2L_2 and mean EPE for each group. We label a 256×256256\times256-pixel window as a hotspot if its maximum absolute EPE exceeds 10 nm and as a non-hotspot otherwise.

MethodHotspot L2L_2 ↓Hotspot mean EPE (nm) ↓Non-hotspot L2L_2 ↓Non-hotspot mean EPE (nm) ↓
TokMan3,639.76.61392.03.49
CurvyILT3,537.65.77380.73.51
Manhattan Assembly965.54.58364.72.51

In hotspot windows, Manhattan Assembly reduces L2L_2 by 72.7% and mean EPE by 20.6% relative to CurvyILT, the best baseline on both metrics. In non-hotspot windows, the L2L_2 gain over the best baseline is smaller, and Manhattan Assembly also achieves the lowest mean EPE. We use hotspot labels only for evaluation. During optimization, the child-gradient discrepancy in Eq. (5) guides the choice of which primitives to split.

Supplementary Fig. 3 compares the rectangle overlays and simulated resist contours before and after adaptive refinement for a pinch and a bridge. The blue dashed outline marks the target layout. The mask panels show how the local primitive configuration changes near the junction and the gap. The corresponding resist panels show that refinement restores the intended connection in the pinch example and reopens the intended gap in the bridge example.

Q2/W2 — Pixel coverage and shared boundaries

W2 — Computing pixel coverage and exposed edge lengths. The coverage M(u)M(u) of a pixel uu is the area of the rectangular union inside that pixel, divided by the pixel area AuA_u. The union counts overlapping regions only once.

For the backward pass, our CUDA kernel clips each rectangle edge to the pixel and subtracts the union of the intervals covered by the interiors of other rectangles. The total length of the remaining intervals is the exposed length ℓ\ell used in Eq. (3). For a right edge, a small outward displacement δ\delta adds area ℓδ\ell\delta to first order. At differentiable configurations, this gives

∂M(u)∂xright=ℓAu.\frac{\partial M(u)}{\partial x_{\mathrm{right}}}=\frac{\ell}{A_u}.

Fully occluded segments contribute zero. By the chain rule, we multiply each pixel’s coverage derivative by ∂L/∂M(u)\partial\mathcal L/\partial M(u) and accumulate the contributions to the rectangle parameters.

Q2 — Assigning gradients at shared boundaries. At a shared internal interface, moving one edge into its neighbor leaves coverage unchanged, while moving it away can open a gap. Our backward convention assigns zero contribution to this interface. For coincident segments on the exterior of the union, we count each shared segment once and distribute its gradient contribution among the participating edges in proportion to their lengths. Completely identical edges therefore receive equal shares.

Thus, the temporary bisection in §3.4 preserves the rendered mask. The children receive gradient contributions from their exposed outer edges, and the newly introduced internal seam contributes zero under this convention. The revised §3.2 (L202–215, L234–237) and Supplementary §D (L164–173) describe the exposed-length computation and the treatment of shared boundaries.

AuthorsOpenReview ↗

Rebuttal (2/2)

W3 — Gradient cancellation and split selection

Thank you for pointing out this distinction. The revised §3.4 (L269–282) clarifies that gradient cancellation is one mechanism by which a fixed primitive can stall despite residual local errors.

This is closely related to the gradient collision identified by AbsGS (Ye et al., 2024). In both settings, opposing local gradients can cancel when aggregated into a single primitive’s gradient, masking the need for finer correction. AbsGS takes the componentwise absolute values of per-pixel positional gradients before summation to preserve their magnitudes in the densification score.

In Manhattan Assembly, we temporarily bisect a rectangle without changing the rendered mask or printing loss. On the coordinates IdI_d selected for the split direction, Eq. (5) compares the sensitivity to a shared child update, ∥(g1+g2)Id∥2\left\lVert(g_1+g_2)_{I_d}\right\rVert_2, with the sensitivity to a differential update, ∥(g1−g2)Id∥2\left\lVert(g_1-g_2)_{I_d}\right\rVert_2. For example, if one half of an edge should move outward and the other inward, their gradients can nearly cancel when the two halves share a parameter. The split allows the two halves to move independently, and the gradient difference measures the sensitivity along that newly available direction.

Figure 7(b) evaluates whether this signal improves split selection. Under the same refinement schedule and per-round caps, discrepancy-based ranking achieves 1.90 nm EPE and 257.9 shots, compared with 2.38 nm and 362.1 shots for parent-gradient ranking and 2.40 nm and 385.2 shots for random ranking. These results support discrepancy-based split selection. Establishing how often gradient cancellation explains the observed loss plateaus would require measuring the child gradients at stalled iterations.

W4 — Computational cost of refinement

All refinement costs are included in the end-to-end turnaround time (TAT) in Table 1. Across the ten ICCAD13-S layouts, temporary splitting and scoring together take about 61 ms per case, or 0.6% of the mean TAT. Loss-based pruning takes 4.92 s out of the 9.73 s mean TAT, accounting for about half of the total runtime.

StageMean time per case
Temporary bisection0.49 ms
Child-gradient evaluation, scoring, and sorting60.6 ms
Loss-based pruning4.92 s
Remaining optimization and logging3.64 s
Other pipeline costs, including I/O1.11 s
End-to-end TAT9.73 s

Temporary splitting and scoring. For NN primitives, constructing temporary bisections takes O(N)O(N) geometric operations. Because each bisection preserves the rendered mask, both split directions reuse the current mask-loss gradient. The additional work consists of renderer backward computations and candidate ranking, with O(Nlog⁡N)O(N\log N) cost for sorting. Split scoring therefore requires no extra lithography simulation.

Loss-based pruning. As shown in Algorithm 1, each pruning check first evaluates all NN single-primitive removals. These trials are independent and can be batched. Candidates that pass the loss threshold are then processed in increasing order of their individual loss changes. Each greedy trial evaluates the mask obtained by removing the candidate together with the already accepted set. A removal is accepted only if the joint loss change is below the threshold and the remaining union satisfies the geometric constraints.

The cap Kp=12K_p=12 limits the number of accepted removals per check. Since rejected candidates also require evaluation, the number TT of greedy trials can exceed 12. Each check therefore evaluates N+TN+T trial masks. The rendering, lithography simulation, and sorting cost is O((N+T)[CR(N)+CS]+Nlog⁡N)O((N+T)[C_{\mathcal{R}}(N)+C_{\mathcal{S}}]+N\log N), where CR(N)C_{\mathcal{R}}(N) and CSC_{\mathcal{S}} are the costs of a forward render and a lithography simulation, respectively. The greedy stage also incurs geometric feasibility checks. We have added the timing breakdown and cost analysis to the supplement.

Comments on the paper

2 comments

Dear Reviewers,

We believe our approach offers a new perspective on a core challenge in computational lithography: the manufacturable Manhattan OPC flow. Drawing on primitive-based representations from computer vision and graphics, we formulate mask optimization as the optimization of explicit geometric primitives. This retains the optimization freedom and flexibility of pixel-based methods while ensuring the manufacturability of Manhattan-based methods.

Our method shares certain similarities with CircleOpt and Shot Splatting. However, both of these approaches focus on the writing shots of e-beam mask writers and aim to jointly optimize shots with OPC or MPC. They start from an existing pixel mask, fit it with shots of different shapes, and then refine it further. In contrast, on ICCAD13, our method starts from uniformly initialized primitives and progressively adjusts their positions and sizes during optimization. On CHIP-L, initialization instead uses a rectangular decomposition of the target layout (§4.1, L330–335). Combined with the splitting and pruning strategies, it freely generates both main patterns and SRAFs, giving it a degree of freedom close to that of pixel-based methods. At the same time, our representation always remains MRC-clean and satisfies the Manhattan constraints. As a result, our method offers greater optimization freedom and is better suited to OPC, a task in which optical proximity effects have a large interaction range and a significant impact on the mask.

Regarding the representation of geometric constraints and MRC, we have explained this in detail in our responses to Reviewer wYhP and Reviewer 3zAu. The geometric constraints are strictly guaranteed throughout optimization by a feasible domain over the primitive parameters, rather than by post-hoc correction. This issue therefore does not affect the final conclusions of the paper, and we have clarified this point in the manuscript.

Regarding the hotspot question raised by Reviewer PLY3 and Reviewer wYhP, hotspots are mentioned only briefly in the main text and were not discussed in detail due to space limitations. Here, hotspots refer to typical lithographic hotspots such as pinches and bridges, i.e., regions where the EPE is significantly large or even leads to opens or shorts. We do not design a dedicated optimization objective for hotspots. Instead, we present them as an observed phenomenon: optimization driven by lithographic gradient feedback naturally corrects these hotspots, which reflects the advantage of our method's optimization freedom. In our response to Reviewer PLY3, we have added a comparison that separates hotspot and non-hotspot regions.

Regarding runtime and experimental fairness, we have added a stage-wise runtime breakdown of the refinement procedure and a quality–runtime analysis (see our responses to Reviewer PLY3 and Reviewer wYhP). We have also shown that the baseline settings are reasonable and that there is no data leakage, through a tiling sensitivity study and a description of the train/test split (see our responses to Reviewer wYhP and Reviewer 3zAu).

We have responded to each reviewer's remaining questions individually under their respective comments. We sincerely thank all reviewers for their valuable feedback, and the corresponding revisions have been incorporated into the main text and the Supplementary Material.

In summary, this work presents an end-to-end, primitive-based Manhattan OPC method that further advances primitive-based optimization in semiconductor manufacturing. We are happy to provide additional experimental details to further clarify our method. Thank you again for your feedback! We hope these clarifications are helpful for your decision.

Dear Reviewer,

Thank you again for your time and valuable feedback. We wanted to kindly follow up on our response to your review. We would greatly appreciate it if you could let us know whether it addresses your concerns, or if any points still need clarification. We would be happy to provide more details or results.

Best regards, The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.