Learning to Search for Executable Patternmaking from Certified Programs: The SemDraft Framework Explained

When AI Learns to "Revise Patterns": A New Challenge for the Patternmaking Industry

There is a long-overlooked fact in garment patternmaking: new styles are rarely drawn from scratch. A patternmaker takes a base pattern and performs a series of editing actions—lengthening the bodice, shifting a dart, changing the sleeve cut. These editing steps determine the final pattern, but the design archive only preserves two versions: before and after modification. The intermediate process is entirely lost.

The arXiv paper Learning to Search for Executable Patternmaking from Certified Programs starts from exactly this observation and proposes a counterintuitive idea: if the steps were never recorded, let an algorithm "search" for an action path from the original pattern to the new one. Building on this, the authors construct the SemDraft framework—reportedly the first system capable of learning to search for executable patternmaking programs from paired "before/after" sewing patterns.

Two keywords here deserve unpacking. "Executable" means the pattern is not a static drawing but a formalized structure represented as a program—one that can be compiled, executed, and verified. "Search" refers to the fact that, in the absence of editing records, the system traverses candidate editing actions until one pattern becomes another.

SemDraft's Triple Certification Mechanism

Searching for a Program, Not Generating a Result

Most existing patternmaking models serve "generation": given an image or text description, output a finished pattern. They don't care how that pattern evolved, nor do they model the operations a patternmaker performed between two versions. SemDraft reverses the task—the input is a pair of before/after patterns, and the output is a program composed of editing actions.

This reversal brings a direct benefit: editing actions are executable code, and therefore can be checked by a compiler. The research uses a deterministic compiler that makes the recovered steps verifiable. Simply put, the searched action sequence cannot merely "look like" it works—it must actually compile the first pattern into the second.

Deterministic compiler here refers to a compilation system that always produces identical output for identical input and introduces no randomness or environment-dependent state during compilation. In the SemDraft scenario, a patternmaking program is represented as a sequence of formalized editing instructions (e.g., "extend the bodice by 2 cm," "translate the dart to the side seam"), and the compiler applies these instructions to the initial pattern to generate the final geometry. Determinism means: as long as the input pattern and action sequence are the same, the output is strictly identical regardless of when or in what environment compilation occurs. This property is the precondition for the subsequent "from-scratch recompilation" and "independent replay" certification checks to hold—if the compiler itself carried randomness or state dependence, then "same result" would no longer prove program correctness, and certification would lose its meaning.

Why Certification Requires Three Checks

The search space easily produces results that are "accidentally right." An action sequence might happen to yield the correct pattern due to some incidental compilation behavior, yet not conform to the actual logic of patternmaking. SemDraft uses three independent checks to filter out such cases:

• From-scratch recompilation: The program must be recompiled from zero, without relying on intermediate state from the search process. This eliminates programs that only hold up by "borrowing" search caches.
• Pairwise action ordering determination: Each pair of editing actions is classified as "ordered" or "commutative." Ordered means swapping the two actions changes the result; commutative means it does not. This step effectively encodes the dependency relationships between patternmaking operations.
• Independent replay: An independent replay mechanism executes the same program and must arrive at the same pattern. This is equivalent to third-party reproduction, ensuring program repeatability.

Only when all three checks pass is a program "certified." Certified programs constitute high-quality training data used to train an action-ranking model.

Commutativity of action pairs is a core concept in process modeling. In the patternmaking context, if two editing actions—"extend the bodice" and "move the dart"—do not affect each other's geometric range of effect, then performing either one first yields the same result, and the pair is commutative; conversely, if "modify the armhole then attach the sleeve" and "attach the sleeve then modify the armhole" produce different patterns, they are ordered. SemDraft has the model perform binary classification on each action pair, which essentially recovers the partial order relationships between patternmaking operations from data. This information has two layers of value: first, it allows the searcher to prune branches that violate known orderings when expanding candidate paths, narrowing the search space; second, it explicitly distills operational dependencies originally implicit in patternmakers' experience into learnable labels, so that the recovered program is not only "correct in result" but also arranged in a way that conforms to real craft logic.

The Gap Between Learned and Non-Learned Rankers

At the core of SemDraft is a model that ranks candidate actions within the search. It is trained on certified programs, then during search decides which editing action to try next with priority.

The experimental results provide a clear comparison: on two fixed, order-sensitive 80-case test sets, with all other search components held constant, the learned ranker certified 63 and 64 cases respectively within 1000 search executions. As a control, the non-learned ranker certified at most 53 and 52. This gap demonstrates that in searching the action space, learned preferences can indeed significantly improve efficiency—with the same execution budget, over a dozen more cases can be certified.

Search budget is key to understanding this comparison. The experiment fixes a budget of "1000 search executions," not runtime or iteration count, meaning the learned and non-learned rankers compete under exactly the same computational cost, and the gap comes solely from the quality of the decision "which candidate action to try first at each step." In a combinatorially explosive action space, even a slight increase in action sequence length causes the number of candidate paths to expand exponentially, so each choice by the ranker amounts to a pruning decision in a vast tree-shaped space. The learned ranker certifying over a dozen more cases shows that action preferences learned from certified programs guide the search toward more promising branches, rather than relying on brute force or random trial and error. This also explains why certified programs are both outputs and training data—they form a self-reinforcing loop.

Why This Matters

The value of SemDraft extends beyond patternmaking. It touches on a broader question: when process data is missing and only input-output pairs remain, can we reconstruct executable processes through search and certification?

Patternmaking archives record only results, not steps—similar to the situation in many domains: engineering design files retain only the final version, intermediate commits in code repositories are squashed, medical records note only prescription outcomes. SemDraft's proposed solution is search plus certification: use search to generate candidate processes, and use a deterministic, independently reproducible compiler as the judge.

For the apparel industry, this means old pattern archives may be reactivated. Those archives with only before/after versions, whose intermediate processes have long been forgotten, have a chance to be restored to the patternmaker's original action paths, and thereby become reusable, teachable editing knowledge.

However, note that this approach currently relies on a deterministic compiler and order-sensitive case design. In scenarios where compilation behavior is unstable, or editing actions themselves are ambiguous (the same pattern can be reached by multiple reasonable paths), the strictness of the certification mechanism may become a ceiling on coverage. The paper does not provide performance data for such scenarios, which is a direction for future validation.

Process mining is a research field with over two decades of history that similarly attempts to reconstruct business process models from event logs. The difference between SemDraft and it is: traditional process mining assumes the existence of timestamped event logs, whereas here there are not even logs—only two static snapshots before and after modification. Therefore SemDraft must first "guess" a sequence of actions in the absence of intermediate records, then use the compiler to verify whether this sequence can truly reproduce the endpoint. This "search plus certification" paradigm is highly isomorphic to "Programming by Example" in the field of program synthesis—the latter also, given input-output examples, has an algorithm search for a program that accomplishes the transformation. Introducing tools from these two fields into the restoration of garment patternmaking archives is the main methodological contribution of this work.

A Turning Point in the Technical Approach

From "generating finished products" to "recovering processes," SemDraft represents a shift in research focus. Generative models solve "making something," while process recovery solves "understanding how something was made." The latter is more difficult because the search space explodes combinatorially with the number of actions, and the correctness standard is stricter—not only must the result be right, but the steps must also be verifiable.

SemDraft uses certified programs as an intermediary to transform an unsupervised search problem into a supervised ranking learning problem. The generality of this idea may be more noteworthy than its direct application to sewing patternmaking.

One-line Summary

SemDraft recovers executable patternmaking programs from before/after pattern pairs through search plus triple certification.

Paragraph Summary

SemDraft is the first framework to learn to search for executable patternmaking programs from paired "before/after" sewing patterns. It relies on no recorded editing steps, instead reversing the task from "generating a finished pattern" to "searching for an action path from the original to the new version." To ensure the recovered programs are truly reliable, the system designs three certification checks: from-scratch recompilation, pairwise action ordering determination, and independent replay, filtering out action sequences that only accidentally hold. Certified programs serve as training data for a learned ranker that ranks candidate actions within the search. Experiments show that on fixed order-sensitive test sets, the learned ranker certified 63 and 64 cases within 1000 search executions, significantly outperforming the non-learned ranker's 53 and 52. The core idea of this method can be generalized to other scenarios where process data is missing.