acceptodds
Withdrawn from ICLR 2027

Learning to Search for Executable Patternmaking from Certified Programs

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Learned models increasingly read and write sewing patterns, and every panel passes through them as a coded boundary that pattern software must accept back.Current boundary codes cut the panel into equal pieces and give each the samenumber of bits. A straight seam then costs as much as an armhole, and the corner between them gets rounded off. We observe that most of the error sits in a few short curves, and that the corners and straight seams that make up most of a panel are charged like curves. To this end, we propose CornerMCQ, a boundary code that spends bits only where the boundary bends and needs no neural network. Specifically, it stores the detected corners on a vertex grid, gives the straight runs between them no curve bits, and describes each remaining curve relative to its chord with a few small codebooks fitted once. On a public corpus and a private industrial archive, CornerMCQ is more accurate than Bézier fitting, PCA, and a learned vector quantizer at equal bits and several times more accurate than the same codebooks on equal pieces; on the public corpus, with fewer bits than the equal-piece code, three panels in four stay within two millimetres of the reference boundary everywhere, against one panel in a hundred.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
sewing patterns, patternmaker, pattern archives, editing actions, deterministic compiler, bounded search, certified programs

Reviews

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

The paper introduces SemDraft, which recovers executable pattern-editing programs from before-and-after sewing patterns without observing editing histories. A bounded search operates over nine semantic editing actions implemented by a deterministic compiler. Recovered programs undergo recompilation, ordering checks, and independent replay, and the resulting programs and dependency DAGs provide supervision for an action-ranking model. In a fixed search framework, the learned ranker achieves higher certified success than heuristic, random, and template-based rankings on synthetic, order-sensitive evaluation sets. The main result is an average of 63/80 certified cases, compared with 51/80 for the heuristic and 53/80 for template lookup.

Critical strengths
  1. Recovering executable edits is a useful problem formulation. The paper goes beyond generating a final pattern and asks how one pattern can be transformed into another through semantic operations. This is particularly relevant when actions jointly affect panels, seams, and attached components. The distinction between reaching a similar endpoint, replaying an executable program, and establishing which actions can be reordered gives the problem more substance than geometric reconstruction alone.

  2. The main ranking comparison is reasonably well controlled. Candidate generation, search framework, stopping criterion, and certification are held fixed rather than changing together with the learned component. The improvement also repeats on a second draw: 64 certified cases for the learned prior versus 52 for the heuristic and 51 for template lookup. This supports a real benefit from the learned ranking within the specified environment, rather than an advantage attributable only to different search machinery. 33799_Learning_to_Search_for_E

Critical weaknesses
  1. The experiments do not yet establish the value of the distinctive learning contribution. DAG supervision gives 63 cases versus 61 for linear imitation on the main test, within the variation across training seeds; on the replication draw both reach 64. Meanwhile, all corpora come from a generator whose action-type sequences are largely determined by tier and depth. The evidence therefore supports learned ranking over this controlled distribution, but not a meaningful advantage from learning the certified partial-order structure. The certificate may still be valuable as an output artifact or training-data filter, but those roles need to be separated from the claimed learning benefit. This matters because the paper otherwise remains close to a domain-specific demonstration of search distillation.

  2. The scope of the dependency certificate is not sufficiently established in Section 3.2. Each action pair is reportedly decided once and cached after being examined at a shared prefix. For state-dependent actions, commutativity at one prefix does not by itself establish commutativity at other reachable prefixes. The subsequent enumeration of linear orders and materialization of downward-closed subsets may address this, but the description does not make clear whether every permitted ordering is checked, or whether one representative state is retained for each completed-action set. This distinction is consequential: the DAG determines which next actions are labeled valid during training. A soundness argument tied to the actual caching and enumeration procedure is needed.

Questions for authors
  1. What incremental benefit is attributable to full partial-order certification, beyond training on executable, replay-validated linear programs? The existing DAG-versus-linear comparison addresses the supervision format but does not separate the contribution of the certification filter. A targeted comparison using the existing recovered programs would help establish the role of this component.

  2. Is a commutativity verdict cached per action pair, or per action pair and prefix state? Does certification verify the endpoint of every topological ordering admitted by the DAG? If the guarantee instead relies on complete static read/write effects, please state the required assumptions and explain why they cover the state-dependent template operations.

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

This paper tackles the task of predicting a sequence of edit operations to convert a given sewing pattern program into a target sewing pattern (given only the target program's "execution" not the program itself). Towards this end, the proposed method, SemDraft uses a neural network to learn a prior over edit operations. To learn this prior, enumerative search is used to generate edit operation sequences that transform one sequence into the other, and a transformer model is then employed, which even the current pattern program, and target pattern, predicts likelihood over potential operations. On a small test set, under a compute-bounded search strategy, the learnt prior performs better than naive heuristics (used to train the network).

Critical strengths

The paper attempts to address a critical challenge.

Critical weaknesses

The central weakness of this method is Neurally Guided search is more than a decade old research direction at this point. It's unclear to me how this method is any different from the prior work.

Fundamentally, the proposed method, first constructs a dataset of edit-sequences using off-the-shelf search. Second, it trains a neural network to predict the edit operations. While the description of how the search is conducted, or what accounts for a "certified" edit sequence under the author's definition is interesting, these are simply domain specific detail (and often quite obvious).

Here is a list of past works that already show the proposed approach in action:

  1. Ritchie et al., Neurally-Guided Procedural Models, NeurIPS 2016.

  2. Ritchie et al., Deep Amortized Inference for Probabilistic Programs, 2016.

  3. Balog et al., DeepCoder: Learning to Write Programs, ICLR 2017.

  4. Kalyan et al., Neural-Guided Deductive Search for Real-Time Program Synthesis from Examples, ICLR 2018.

  5. Ellis et al., Learning to Infer Graphics Programs from Images, NeurIPS 2018.

  6. Polosukhin & Skidanov, Neural Program Search, 2018.

  7. Ellis et al., DreamCoder: Bootstrapping Inductive Program Synthesis with Wake-Sleep Library Learning, PLDI 2021

If the authors do believe their approach stands out from the past work, the current draft does a poor job of convincing me as a reader. In fact, even the related work section simply describes related work, rather than explaining how the proposed method compares to existing works or why it's different or novel.

On the topic of related work, the paper also poorly situates this work. For instance, It is motivation with Line 41 - "The operations recovered by inverse CAD methods act on a single solid" - but that is simply untrue in 2026. Many CAD methods now recover symmetry groups and even more advanced non-local operators.

  1. Szalinski: Synthesizing Structured CAD Models with Equality Saturation and Inverse Transformations — Nandi et al., PLDI 2020.

  2. ShapeAssembly: Learning to Generate Programs for 3D Shape Structure Synthesis — Jones et al., SIGGRAPH Asia 2020.

  3. CAD-Recode: Reverse Engineering CAD Code from Point Clouds — Rukhovich et al., ICCV 2025. https://arxiv.org/abs/2412.14042

The paper's second weakness is its exposition. The language is very imprecise for a paper submission. For instance, the abstract itself states, "A deterministic compiler makes the recovered steps checkable. To this end, we present SemDraft, the first framework that learns to search for executable patternmaking programs from paired before-and-after sewing patterns without recorded editing steps." First, I think it's pretty obvious that a compiler can be used to check (why state this?).Second, how does the neural network serve this end (What is the "Towards this end," pointing towards?).

It has some other similar issues: Line 52 - "the three-stage verification" - The introduction has not yet defined what this is. Line 209: "The certifier then enumerates the reachable linear orders, materialises every downward-closed subset of the resulting dependency DAG as an executable intermediate state, and applies a minimality rule: no proper downward-closed subset may already be tight." - completely unparsable sentence. none of the terms have been defined linear order, downward-closed subset, subset being tight etc.

Finally, the experiments are also quite lacking. There is no ablation over larger beam sizes. (Does the improvement from the learnt prior vanish if I set search beam-size to 10?). What if directly try to apply some of the existing methods such as PLAD etc. (where we do not try to initially build ideal GT set, but rather bootstrap on partially correct edit sequences). Or for instances, considering Diffusion Trees (Diffusion On Syntax Trees For Program Synthesis).

Questions for authors

Does the improvement from the learnt prior vanish if I set search beam-size to 10? How will the proposed method compare to diffusion trees or PLAD?

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

The paper addresses how to recover executable editing programs that turn a base sewing pattern into a target pattern when no editing steps are recorded. To recover such programs, the authors propose SemDraft that incorporates a deterministic compiler over nine semantic patternmaking actions and uses bounded teacher search to find candidate action programs and accepts recovered certified programs only after it passes three checks i) recompilation ii) pairwise order/dependency checking, and iii) independent replay. It then uses these certified programs to train a model that ranks actions during later searches. The authors also use an action dependency graph to allow more than one valid action order during training. On a synthetic benchmark, the learned ranking method finds more verified solutions than a hand-designed heuristic, random ranking, and template lookup under the same search budget.

Critical strengths
  • Although the paper focuses on garment editing, the problem has a clear connection to program synthesis, programming by example (PBE), and learning from missing action labels. Just like PBE works on input/output pairs, SemDraft synthesizes a program that transforms the base pattern (input) into target pattern (output). In real design work, people often start from an existing pattern and make a series of edits. Recovering those edits from only the starting and final patterns is useful as the edit history may not be recorded.
  • The authors do not treat every program found by search as correct. They run the program again, check which actions must occur in a certain order, and use a separate replay check to confirm the result. This gives a clear way to filter training examples when human edit histories are unavailable. The dependency graph also records when several action orders are acceptable. I like this design because it links the training labels to actions that the system can actually execute, rather than relying only on a predicted action sequence.
Critical weaknesses

I really like the idea of applying program synthesis and learning concepts in real industry work settings. However, I have few concerns about the novelty and evaluation of SemDraft.

  • My main concern is that the new learning contribution is not clearly separated from existing ideas. SemDraft uses beam search to find programs, a verifier to filter them, and a Transformer to rank future actions. Learning from search results and training on more than one valid next action have both been studied before, as discussed in related work. Methods such as DeepCoder, Neural-Guided Deductive Search, and CrossBeam already use learned predictions or policies to guide program search. This paper brings these ideas together in an interesting setting, but it is less clear which part is a new learning method. I would like the authors to explain more directly what is technically new and why existing methods cannot solve the same problem with similar changes.
  • The evaluation is limited to synthetic patterns created using the same fixed set of nine editing actions that the method can search over. This is a useful first test, but real sewing patterns may contain edits, shapes, or errors that are not covered by this setup. The candidate action providers also use information about the target pattern, which may make search easier than in less structured settings. More importantly, the paper reports poor results when a garment family or action combination is not seen during training. For example, the learned policy solves none of the 57 hard cases in the held-out composition test. These results raise concerns about how well the method can work beyond the current training and test setup.
  • The main result comparisons use a hand-designed heuristic, random ranking, and a lookup based on training data statistics. These are useful controls, and I appreciate that they share the same search setup. However, the paper does not test other learned ranking methods or program synthesis methods adapted to this action space. As a result, it is hard to know whether the Transformer and the proposed training process offer a clear advantage over simpler learned models. A stronger baseline comparison is needed like a small supervised ranking network or another learning-based search or an adapted program synthesis approach for this domain settings.
Questions for authors
  • (Q1) Please clarify which part represents the main new learning contribution compared with prior work on learning from search and multiple valid actions?
  • (Q2) Could the authors compare SemDraft with additional learning-based methods, such as a simpler neural ranking model or an existing learning-based program synthesis approach?
  • (Q3) Could the authors explain the main reasons for hard case failures and provide additional experiments that improve or evaluate generalization?

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

Related papers

Discussion (0)

Sign in to comment.