Lexically Constrained Neural Machine Translation with Levenshtein Transformer

ArXiv: 2004.12681

🎯 Pitch

For the first time, we can inject specific terminology into neural machine translation at runtime with no speed penalty—not 3× slower like previous beam-search methods. The trick is to seed an edit-based Levenshtein Transformer with the required words before it starts refining, achieving 100% term coverage and up to +0.96 BLEU without any retraining.

---

1. Executive Summary

This paper proposes a simple inference-time algorithm for enforcing lexical constraints in neural machine translation by injecting pre-specified terminology directly into the decoding process of a Levenshtein Transformer (LevT) — an edit-based, non-autoregressive generation model that iteratively refines output through deletion and insertion operations — without any model retraining or reduction in decoding speed. The method operates by populating the initial target sequence with constraint tokens before the first refinement iteration and optionally disallowing their deletion or the insertion of new tokens within multi-word constraint phrases (a constraint insertion step followed by a constraint mask that forces the deletion classifier to "keep" all constraint positions), achieving 100% term usage on WMT English-German test sets while maintaining the same ~260 sentences per second decoding throughput as unconstrained LevT. The approach yields statistically significant BLEU improvements over an unconstrained LevT baseline (up to +0.96 BLEU on Wiktionary-constrained WMT'17 data) and outperforms prior constrained decoding methods like dynamic beam allocation, establishing that lexical control can be reliably guaranteed at no speed penalty only when the non-autoregressive edit-based decoding framework provides flexibility to interleave constraints with freely generated tokens through the same insertion and deletion mechanisms used in standard inference.

2. Context and Motivation

The Core Problem: Lexical Control Without Retraining or Decoding Slowdown

The fundamental problem this paper addresses is deceptively straightforward to state but remarkably difficult to solve in practice: how can a neural machine translation system reliably produce specific, user-specified terminology in its output — like a brand name, technical term, or in-domain vocabulary — without requiring the model to be retrained and without making the translation process slower?

This problem manifests in a concrete, everyday scenario that the paper opens with: imagine an E-commerce NMT system trained on general web data. When it encounters the Chinese term "红米" (a smartphone brand), it has no training exposure to the correct translation "Redmi." Instead, it decomposes the characters literally and produces "red rice" — a semantically plausible but commercially disastrous output. In regulated industries (medical, legal, financial), in global E-commerce, and in enterprise localization, such failures are not merely inconvenient — they can carry legal liability, damage brand identity, or render content unusable for its intended audience.

The seeming simplicity of the problem masks why it is genuinely hard in the NMT paradigm. Autoregressive Transformer models generate tokens left-to-right, conditioning each prediction on all previously generated tokens. The decoder's beam search explores a combinatorial space of partial hypotheses, each scored by the model's learned probability distribution. Inserting a specific multi-word phrase at a specific position requires the decoder to coordinate multiple decisions: it must generate the correct token sequence for the constraint, place it at a grammatically and semantically appropriate position in the output, and ensure that the surrounding generated text is fluent and faithful to the source — all while respecting the left-to-right generation order. This is fundamentally at odds with how autoregressive models are trained (to maximize likelihood of reference translations, not to satisfy hard constraints) and how they decode (greedy or beam search over model probabilities, not constraint satisfaction).

The paper frames this as a control problem: NMT systems produce higher-quality translations than their phrase-based predecessors, but at the "cost of losing control over how translations are generated." The statistical nature of end-to-end neural models — their strength for fluency and adequacy — becomes a liability when domain experts, terminologists, or business stakeholders need specific guarantees about output content.

Why This Problem Matters: Practical and Theoretical Dimensions

Practical stakes. The motivation is grounded in real-world MT deployment workflows. In enterprise settings, domain-specific glossaries and terminology databases are standard infrastructure — organizations maintain curated bilingual dictionaries (e.g., IATE for EU terminology, proprietary glossaries for corporate brands and product names) that human translators and older rule-based or phrase-based MT systems can consult. NMT systems break this workflow because there is no explicit mechanism to inject these resources. The paper notes that "machine translation users often maintain in-domain dictionaries to ensure that specific information is translated accurately and consistently" — a practice that NMT threatens to disrupt unless controllable decoding solutions are developed.

The consequences of unconstrained NMT go beyond brand names. In medical translation, swapping one drug name for another can be catastrophic. In legal translation, inconsistent rendering of defined terms ("force majeure," "indemnification") can alter contractual meaning. In technical documentation, referring to the same component by different names across sections creates confusion. These are all scenarios where terminological consistency is a hard requirement, not a nice-to-have.

Theoretical significance. The problem also exposes a deeper tension in the NMT paradigm between fluency and controllability. The very properties that make Transformer-based NMT successful — end-to-end training, distributed representations, soft attention — are what make it opaque to external constraints. Unlike phrase-based MT, where the translation model consists of explicit phrase pairs that can be directly manipulated (insert a known translation for a known source phrase), NMT's knowledge is embedded in high-dimensional parameter matrices that resist targeted intervention. Lexical constraint enforcement becomes a test case for a broader question: can we retain the fluency advantages of neural generation while recovering the controllability that older, more transparent architectures provided?

The problem also sits at the intersection of efficiency and control. Prior work had shown that constraints could be enforced — through modified beam search, data augmentation, or placeholder mechanisms — but always at a cost to decoding speed. The paper's explicit framing is that this speed penalty is not a necessary evil but an artifact of the autoregressive decoding paradigm. By shifting to a non-autoregressive, edit-based framework, the speed and control objectives become compatible rather than conflicting.

Prior Approaches and Their Shortcomings

The paper organizes previous work into two families, each with fundamental limitations that motivate the proposed approach.

Constrained training approaches. One line of work modifies the training procedure so that the model learns to handle constraints naturally:

• Placeholder mechanisms (Crego et al., 2016): Entities in the training data are replaced with placeholder tokens (e.g., __ENTITY_1__) that pass through the model unmodified and are substituted back in a post-processing step. While this provides some control, the paper notes it does "not reliably guarantee the presence of the constraints at test time" — the model may generate placeholders in wrong positions, drop them, or duplicate them, and the mechanism only works for constraints that were identified during training.

• Code-mixed training (Song et al., 2019; Dinu et al., 2019): The source sentence is augmented to include the target-language constraint phrase alongside the source text (e.g., the English source "charge" becomes "charge berechnen" when the constraint is that "charge" must translate to the German "berechnen"). The model is then trained on this code-mixed data, learning to copy the target constraint into the output. This approach has two weaknesses the paper identifies: first, it requires retraining whenever the constraint vocabulary changes — impractical for dynamic, user-supplied glossaries; second, it "does not reliably guarantee the presence of the constraints at test time" because the model learns a statistical association rather than a hard rule. The constraint may be dropped, particularly when it conflicts with the model's learned translation preferences.

• Factored training (Dinu et al., 2019, additional approach): An extension that adds explicit constraint features to the model architecture, increasing complexity but not fundamentally changing the retraining requirement or reliability limitation.

The common failure mode across constrained training approaches is that they treat constraints as a training-time data augmentation problem rather than an inference-time enforcement problem. Because the model learns to use constraints statistically rather than obey them algorithmically, there is no guarantee. A deployment scenario where a user uploads a new glossary tomorrow and needs translations immediately — without retraining — is not served by any of these methods.

Constrained decoding approaches. A second family modifies the inference procedure — specifically beam search — to force constraint tokens into the output:

• Grid beam search (GBS) (Hokamp and Liu, 2017): Beam search is extended to track not just the sequence probability but also which constraints have been satisfied. The search state includes a bitmask of completed constraints, and hypotheses are organized into separate beams based on how many constraints they've covered. The search space grows as the product of the sequence length, vocabulary size, beam width, and number of constraint subsets — a multiplicative explosion.

• Dynamic beam allocation (DBA) (Post and Vilar, 2018): An optimization of GBS that dynamically distributes the beam budget across constraint-satisfaction states rather than maintaining separate beams, reducing overhead. The paper reports that Post and Vilar achieved ~99.5% term usage on Wiktionary-constrained WMT data (Table 3), demonstrating that reliability is achievable. However, the paper also notes a critical cost: Post and Vilar "reported 3× slow down compared to standard beam search." This is not a small constant factor — it makes constrained decoding impractical for latency-sensitive applications.

• Vectorized DBA (Hu et al., 2019): Further optimization of DBA using batched constraint checking and GPU vectorization, improving the speed but not eliminating the fundamental overhead of constraint tracking within the autoregressive loop.

• Finite-state acceptors (Hasler et al., 2018): Constraints are compiled into finite-state machines that run alongside the decoder, accepting or rejecting partial hypotheses based on constraint coverage. This adds per-step checking overhead that "monotonically increases decoding time."

The common failure mode across constrained decoding approaches is the speed-control tradeoff. Achieving high term usage means the beam search must actively track constraint coverage, which adds computation to every decoding step. Because autoregressive decoding is inherently sequential (each token depends on all previous tokens), this overhead cannot be parallelized away. The paper summarizes the state of affairs bluntly:

"While being mostly effective at forcing the inclusion of pre-specified terms in the output, these approaches further slow down the beam search process."

This is the gap the paper targets: reliable constraint enforcement at no decoding speed penalty. The key insight is that this goal is achievable only by abandoning autoregressive decoding entirely.

The Non-Autoregressive Opportunity

The paper's positioning hinges on a technological shift that had been gaining momentum at the time of writing: non-autoregressive machine translation (NAT). The key idea of NAT (Gu et al., 2018) is to generate all target tokens simultaneously rather than left-to-right, which enables massive parallelism and dramatically lower inference latency. However, early NAT models sacrificed translation quality for speed — the independence assumption between output tokens led to "multi-modality" problems (the same source could map to multiple valid translations, and independent token generation produced incoherent mixtures).

The paper draws on a specific lineage of NAT models that address the quality gap through iterative refinement:

• Iterative refinement NAT (Lee et al., 2018): Instead of generating all tokens in one shot, the model produces an initial guess and then repeatedly refines it, conditioning on the previous iteration's output. This breaks the independence assumption — tokens in later iterations are conditioned on the full previous output — while retaining much of the parallelism advantage.

• Insertion Transformer (Stern et al., 2019): Refinement is recast as an insertion operation — the model starts with a skeletal output (or just boundary tokens) and repeatedly predicts where and what to insert. This is conceptually akin to building a sequence by filling in gaps.

• Levenshtein Transformer (LevT) (Gu et al., 2019): The culmination of this line, combining deletion and insertion operations in an alternating refinement loop. The model learns to delete tokens that don't belong and insert tokens where the sequence is incomplete. This edit-based formulation has a crucial property that the paper exploits: it naturally handles sequences where some tokens are fixed and others need to be generated around them. Because LevT is trained to accept partially complete sequences and refine them through edits, it can be seeded with constraint tokens before the first refinement iteration — the model simply treats them as pre-existing tokens that need to be integrated into a complete, fluent output.

This property is the intellectual fulcrum of the paper. Autoregressive models have no mechanism for "here are some tokens I want in the output; please generate the rest around them" — they generate left-to-right and can't easily integrate pre-specified mid-sequence tokens. LevT, by contrast, is designed to operate on incomplete sequences with tokens at arbitrary positions. The paper's contribution is recognizing that this architectural property — originally designed for parallel decoding speed — also solves the lexical constraint problem as a "free" side effect.

How This Paper Positions Itself

The paper positions itself at the intersection of two previously separate research threads: lexical constraint enforcement (which had been studied exclusively in autoregressive settings) and non-autoregressive decoding (which had been studied primarily for speed, not controllability). The novelty claim is the synthesis:

"Different from the existing line of work, we invoke lexical constraints using a non-autoregressive approach."

This is more than a "first application of NAT to constraints." The paper argues that the LevT architecture is uniquely well-suited to the problem in a way that other NAT approaches are not. Mask-predict models (Ghazvininejad et al., 2019), for example, generate all tokens in parallel and then iteratively replace low-confidence tokens — but tokens are still generated from scratch at each position. There is no natural way to inject a constraint and guarantee it persists through refinement. LevT's deletion classifier gives it an explicit "keep or remove" decision for each token, which the paper's constraint mask can override — a mechanism that has no analog in other NAT architectures published at the time.

The paper's empirical positioning is also carefully constructed. Table 3 compares against both constrained training (DINU19) and constrained beam search (POST18) on the same test sets, with the same evaluation metrics. The results show:

• 100% term usage — matching or exceeding POST18's 99.5%/82.0% and DINU19's 93.4%/94.5% on Wiktionary/IATE respectively.
• Higher BLEU — despite starting from a stronger baseline (LevT at 30.24 BLEU vs. the Transformer baseline at 26.00), the constrained LevT achieves 31.20 BLEU vs. DINU19's 26.30 and POST18's 25.80.
• No speed penalty — ~260 sentences/second with or without constraints (Table 1), dramatically faster than the 3× slowdown reported for beam-search methods.

The paper explicitly claims that its approach "does not require any modification to the training procedure and can be easily applied at run-time with custom dictionaries" — a direct contrast to constrained training approaches that require retraining per dictionary. And it claims "no impact on decoding speed" — a direct contrast to constrained beam search approaches that incur significant overhead.

This dual positioning — better control than training methods, faster than decoding methods — defines the paper's contribution space and explains why the LevT architecture is more than an arbitrary NAT choice: it is the specific mechanism (edit-based refinement with explicit keep/delete decisions) that makes the synthesis possible.

3. Technical Approach

3.1 Reader Orientation

The system being built is a lexically constrained decoder — a machine translation inference procedure that takes a source sentence and a user-supplied list of target-language terms (constraints) and produces a translation that is guaranteed to contain every constraint while remaining fluent and faithful to the source. It solves the problem of terminology enforcement by exploiting a non-autoregressive architecture that naturally operates on partially complete sequences, treating user-specified constraints as pre-existing tokens that the model integrates into its output through its normal iterative refinement process rather than as separate requirements that must be tracked and enforced through external machinery.

3.2 Big-Picture Architecture (Diagram in Words)

The system has three major components that operate in sequence during decoding, with no change to the training pipeline:

1. Transformer Encoder — a standard 6-layer Transformer encoder that processes the source sentence and produces source-side contextual representations, exactly as in the original LevT model and used identically regardless of whether constraints are present.

2. Levenshtein Transformer Decoder — a shared 6-layer Transformer decoder block that runs three different classifier heads (deletion, placeholder, token) on top of the same hidden representations, operating in an iterative refinement loop that alternates between deleting tokens that don't belong and inserting tokens where the sequence is incomplete. This is the core generation engine and is unchanged from the original LevT.

3. Constraint Injection Module — a lightweight, inference-only mechanism that (a) inserts the target constraint tokens into the initial decoding sequence before the first refinement iteration, (b) optionally applies a binary constraint mask to prevent the deletion classifier from removing any constraint token, and (c) optionally suppresses placeholder insertion between tokens of the same multi-word constraint to keep those phrases intact. This module has no learnable parameters and imposes no measurable speed overhead.

Information flows as follows: the source sentence enters the encoder (producing contextual embeddings used throughout) → before the first decoder iteration, the constraint injection module populates the initial target sequence y_0 with constraint tokens instead of starting from empty brackets → the deletion classifier runs, forced by the constraint mask to "keep" all constraint positions → surviving tokens (including all constraints) pass through the placeholder classifier, which predicts how many new tokens to insert between each pair of consecutive tokens, with the constraint mask optionally setting this to zero within multi-word constraints → [PLH] tokens are inserted at the predicted positions → the token classifier replaces each [PLH] with an actual target language token → the resulting sequence becomes the input for the next refinement iteration → the loop continues until the sequence stabilizes or a maximum number of iterations is reached.

3.3 Roadmap for the Deep Dive

• First, the Levenshtein Transformer architecture and training, because understanding the three-classifier refinement loop and why it naturally handles partially complete sequences is prerequisite to seeing how constraint injection works — the paper's contribution is a minimal modification to this existing framework, not a new model.
• Second, the MDP formulation of LevT decoding, since it makes precise the state space, action space, and transition dynamics that constraint injection intervenes on — specifically what y_k looks like at each iteration k and how the three classifiers transform it into y_{k+1}.
• Third, the constraint injection procedure itself — the step-by-step mechanics of populating y_0 with constraints, the constraint mask mechanism, and the optional deletion prohibition and insertion suppression — since this is the paper's novel contribution and its simplicity is the key claim.
• Fourth, the speed analysis — since "no impact on decoding speed" is a headline claim, we need to understand exactly why constraint injection adds no measurable overhead to the iterative refinement loop.
• Fifth, the design choices and their justifications — why LevT over other NAT architectures, why the specific mask mechanisms, and what alternatives were implicitly rejected.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a method application paper whose core idea is that the Levenshtein Transformer's edit-based iterative refinement loop — specifically its explicit deletion classifier that makes a binary "keep or remove" decision for every token position — can be hijacked at inference time to guarantee the persistence of user-specified terminology without any architectural changes, retraining, or speed penalty, simply by seeding the initial decoding state with the constraint tokens and overriding the deletion decisions at those positions.

---

Levenshtein Transformer Architecture and Training

The Levenshtein Transformer (LevT) is an encoder-decoder model built on the standard Transformer architecture (Vaswani et al., 2017) with multi-headed self-attention and feed-forward networks, but its decoder operates fundamentally differently from the autoregressive left-to-right token generation found in conventional Transformers. The encoder is standard: it processes the source sentence and produces a sequence of hidden representations that will be attended to by the decoder at every refinement step. The innovation is entirely in the decoder's operation.

The LevT model used in this paper follows the base Transformer configuration: 6 encoder layers and 6 decoder layers, each with 8 attention heads, model dimension d_model = 512, and feed-forward network hidden dimension d_ff = 2048. The source and target embeddings are tied (shared vocabulary), and positional embeddings are learned rather than sinusoidal. The vocabulary is constructed using byte-pair encoding (BPE) with 32,000 merge operations, resulting in a shared vocabulary of 39,843 subword tokens for English-German and 39,348 for Romanian-English.

The LevT is trained using sequence-level knowledge distillation (Kim and Rush, 2016). This means that instead of training directly on reference translations, the training targets are the beam search outputs of a separately trained autoregressive Transformer teacher model. The rationale — which the paper inherits from Gu et al. (2019) — is that non-autoregressive models struggle with the multi-modality of natural language (the same source sentence can have multiple valid translations, but NAT's parallel generation forces it to commit to one without seeing context) and distillation provides cleaner, more deterministic targets that the NAT model can learn more easily. The specific training data consists of 3,961,179 distilled sentence pairs released by Gu et al. (2019), which are the teacher Transformer's beam search outputs for the WMT training data.

Training hyperparameters (Table 4 in the Appendix):

• Label smoothing: 0.1
• Dropout: 0.3
• Weight decay: 0.01
• Learning rate: 0.005
• Warmup updates: 10,000
• Effective batch size in tokens: 64,000
• Maximum updates: 300,000

These are the hyperparameters from the original LevT paper; the authors do not modify them.

The critical architectural detail — and the one that makes constraint injection possible — is that the same Transformer decoder block is shared across three different classifier heads. After the standard self-attention and cross-attention layers produce hidden representations for each position in the current target sequence, these representations are fed into three separate linear projections, each trained for a different task:

1. Deletion Classifier: A binary classifier (one logit per position) that predicts whether each token in the current sequence should be kept (label 0) or deleted (label 1). This is trained with binary cross-entropy against ground-truth deletion labels derived by comparing the current partial sequence to the target sequence using the Levenshtein edit distance algorithm — tokens that appear in the target are marked "keep," tokens that don't are marked "delete."

2. Placeholder Classifier: A classifier that, for each gap between consecutive tokens (including before the first token and after the last), predicts how many new tokens need to be inserted. This is a categorical prediction over possible insertion counts (0, 1, 2, ..., up to some maximum), trained against the number of tokens that the Levenshtein alignment indicates should appear in that gap.

3. Token Classifier: A standard vocabulary-sized classifier (one distribution over the 39,843-token vocabulary per position) that predicts which actual target-language token should replace each [PLH] placeholder token. This is trained with standard cross-entropy against the ground-truth token identity.

The three classifiers run sequentially (deletion first, then placeholder prediction and [PLH] insertion, then token replacement) within each refinement iteration, but each classifier operates on all positions in parallel — this is where the speed advantage comes from. Unlike autoregressive decoding, where generating token t requires waiting for token t-1 to be generated, all deletions happen simultaneously, all placeholder insertions happen simultaneously, and all token predictions happen simultaneously. The sequential dependency is only between these three stages, not between individual token positions.

---

The Markov Decision Process Formulation of LevT Decoding

LevT decoding is formalized as a Markov Decision Process (MDP) where the state at iteration k is the current target sequence y_k = (y_1, y_2, ..., y_n) bounded by the start token <s> at position 1 and the end token </s> at position n. The MDP transitions from y_k to y_{k+1} through a sequence of three deterministic (greedy) operations, each conditioned on the encoder output (the source representation) and the current decoder state:

Step 1: Deletion. Every position i in y_k is independently scored by the deletion classifier, which produces a binary decision d_i ∈ {keep, delete}. All positions predicted as "delete" are removed from the sequence. The surviving tokens maintain their original relative order. The boundary tokens <s> and </s> are never deleted (they are treated as always "keep"). The output of this step is a potentially shortened sequence.

Step 2: Placeholder insertion. For every consecutive pair of surviving tokens (including the gap before <s> and the gap after </s>, though in practice only gaps between tokens are relevant), the placeholder classifier predicts an integer count p_j ≥ 0 representing how many tokens need to be inserted at that gap. Exactly p_j copies of the special [PLH] token are inserted into the sequence at gap j. If p_j = 0 for all gaps, no tokens are inserted and the sequence length does not change. The output of this step is a sequence containing both surviving original tokens and newly inserted [PLH] tokens.

Step 3: Token prediction. Every [PLH] token in the sequence is independently processed by the token classifier, which produces a probability distribution over the full vocabulary (39,843 tokens). The most probable token (greedy decoding) replaces each [PLH]. Original (non-placeholder) tokens are not modified in this step — only placeholders get assigned real token identities. The output of this step is a complete target-language sequence (no more placeholders), which becomes y_{k+1}.

Termination condition. The refinement loop continues until one of two stopping conditions is met: (1) y_{k+1} = y_k — the sequence has not changed from the previous iteration, indicating convergence — or (2) a maximum number of refinement iterations has been reached (this maximum is a hyperparameter set during decoding; the paper does not specify the exact value but it follows the original LevT configuration).

Initial state. In standard (unconstrained) LevT decoding, the initial sequence y_0 consists of only the boundary tokens: y_0 = <s> </s>. The model must generate everything between them from scratch through iterative insertion and deletion. This is the key design choice that the paper alters: by populating y_0 with constraint tokens between the boundary tokens before the first deletion operation, the model starts from a partially complete state and refines it rather than building from nothing.

Why an MDP formulation matters for constraints. The MDP framing makes explicit what the constraint injection mechanism does: it changes the initial state distribution of the decoding process. In standard LevT, the initial state is deterministic (always <s> </s>). In constrained LevT, the initial state is a function of the user's constraint list — y_0 = <s> C_1 C_2 ... C_m </s> — where each C_i is a possibly multi-token phrase. The transition dynamics (deletion, placeholder insertion, token prediction) remain unchanged. The model's learned policy — its deletion classifier, placeholder classifier, and token classifier — is applied to this modified initial state and continues to be applied iteratively. Because the policy was trained to handle arbitrary partial sequences (every training example involved refining incomplete intermediate states), it generalizes naturally to constraint-seeded initial states without any fine-tuning.

---

Constraint Injection Procedure

This is the paper's sole novel contribution — the mechanism by which user-specified terminology is injected into and guaranteed to persist through the LevT refinement loop. It consists of three components: the initial seeding of y_0, the optional deletion mask, and the optional insertion suppression. These are applied only at inference time; the training procedure is entirely unmodified.

Constraint insertion (Step 0, before the first deletion operation). Given a list of m target-language constraints C_1, C_2, ..., C_m, where each constraint C_i is a phrase that may consist of one or more subword tokens C_i = (w_i^1, w_i^2, ..., w_i^{|C_i|}), the constraints are simply concatenated in order between the boundary tokens to form the initial sequence:

$y_0 = \texttt{<s> } C_1 \texttt{ } C_2 \texttt{ } ... \texttt{ } C_m \texttt{ </s>}$

This is literally string concatenation: if the constraints are ["Nevada", "Pilot@@ projekt"] (where "@@" indicates a BPE continuation token), then y_0 = <s> Nevada Pilot@@ projekt </s>. If there are no constraints, y_0 = <s> </s> and the decoding is identical to standard LevT — the mechanism degrades gracefully to the unconstrained baseline.

This initial sequence then enters the normal refinement loop, starting with the deletion classifier. The model sees this partially complete sequence, attends to the source encoding, and decides (through its learned deletion policy) which tokens to keep, what to insert where, and what tokens to generate.

Why this works at all — the critical insight. The LevT decoder was trained to refine sequences that are missing tokens, contain extraneous tokens, or have tokens at incorrect positions — the distillation training generates such intermediate states by comparing the model's predictions to the teacher output at each step of the refinement process. When y_0 contains constraint tokens, the model's deletion classifier evaluates each constraint token in context: does this token belong in the final translation given the source sentence? If the constraint is appropriate (the source sentence does contain the concept the constraint represents), the deletion classifier will naturally predict "keep" for those positions — no mask needed. If the constraint is inappropriate or incompatible with the source, the deletion classifier may predict "delete." This is the behavior observed in Table 1: with only constraint insertion (+ Constr. Ins.) and no mask, term usage is 94.43% on the constrained test set — not 100%, because some constraints are deleted by the model. The remaining ~5.6% of constraints are deleted because the model's learned policy considers them inappropriate in context.

The constraint mask: disallowing deletion (+ No Del.). To guarantee that constraints survive to the final output, the paper introduces a binary mask over token positions. Before each deletion operation, the system identifies which positions in the current sequence correspond to constraint tokens (tracking them through insertions and deletions from previous iterations) and creates a mask M where M_i = 1 if token i belongs to any constraint and M_i = 0 otherwise. The deletion classifier's prediction for position i is then overridden:

$\text{action}_i = \begin{cases} \texttt{keep} & \text{if } M_i = 1 \\ \text{deletion\_classifier}(y_k, i) & \text{if } M_i = 0 \end{cases}$

In plain language: every position marked as constraint is forcefully classified as "keep" regardless of what the model predicts. The model's deletion classifier still runs normally on all other positions, and the mask is recomputed after every deletion and insertion operation (since token positions shift when tokens are added or removed).

Implementation detail: tracking constraints through refinement. The constraint mask cannot be a simple static array over the initial positions because insertions and deletions change the sequence. The paper states:

"The positions in this mask are re-computed accordingly after each deletion and insertion operation."

This means the system maintains a set of constraint token identifiers (the actual subword tokens) and, after each refinement step, scans the updated sequence to find where those tokens appear and sets the corresponding mask positions. If a constraint token gets deleted (which shouldn't happen with masking, but the tracking logic handles general cases), it is no longer in the sequence and is not masked. If new tokens are inserted adjacent to or within constraints (see next section), the mask is recomputed to cover only the original constraint tokens.

The insertion suppression: disallowing placeholder insertion within multi-word constraints (+ No Ins.). A subtle problem arises when a constraint consists of multiple subword tokens, such as "Pilot@@ projekt" (two BPE tokens). The placeholder classifier predicts, for every adjacent pair of tokens, how many new tokens should be inserted. If it predicts a non-zero count for the gap between "Pilot@@" and "projekt", a [PLH] token will be inserted between them, and the token classifier will later assign it a real token — effectively splitting the constraint phrase with a spurious inserted word.

To prevent this, the paper optionally prohibits the placeholder classifier from predicting any insertions in gaps that fall within a multi-token constraint. Formally, for a gap between consecutive tokens that both belong to the same constraint C_i, the system forces the placeholder count to zero:

$p_j = 0 \quad \text{for all gaps } j \text{ where both neighboring tokens are in the same constraint } C_i$

For gaps between the end of one constraint and the start of another, or between a constraint token and a non-constraint token, the placeholder classifier operates normally. This keeps each multi-word constraint as an atomic unit — tokens may be inserted before it, after it, or between different constraints, but never inside it.

The full sequence of operations with all controls enabled. Putting it all together, the constrained decoding proceeds as:

1. Initialize: y_0 = <s> C_1 C_2 ... C_m </s>
2. Iteration loop (repeat until convergence or max iterations): a. Compute constraint mask: Scan y_k to identify positions of all constraint tokens; set M_i = 1 for those positions. b. Deletion: Run deletion classifier on all positions; override positions where M_i = 1 to "keep"; remove all other "delete" positions; update the sequence. c. Recompute mask: The sequence has changed (tokens removed), so rescan to update constraint token positions. d. Placeholder prediction: Run placeholder classifier on all gaps; for each gap, if both neighboring tokens belong to the same constraint, force p_j = 0; otherwise use the predicted count; insert p_j copies of [PLH]. e. Token prediction: Run token classifier on all [PLH] positions; replace each with the most probable token; non-placeholder tokens remain unchanged. f. Update: y_{k+1} is the resulting sequence.
3. Check stopping condition: If y_{k+1} = y_k or max iterations reached, terminate; otherwise return to step 2a.

The constraints are guaranteed to appear in the final output (100% term usage when both "No Del." and "No Ins." are active, as shown in Table 1 and Table 3) because:

• They are never deleted (mask overrides deletion classifier).
• They are never split by intra-constraint insertions (placeholder count forced to zero).
• They are never modified by the token classifier (only placeholders get reassigned).

They could theoretically be reordered — since the deletion mask only forces "keep" and doesn't control token position — but in practice, BPE tokenization of constraint phrases and the model's tendency to maintain word order means reordering within a constraint is unlikely for the language pairs tested (the paper notes that 97-99% of constraints in English-German appear in the same order as the source terms, making reordering a minor issue for this language pair).

---

Speed Analysis: Why There Is No Measurable Overhead

The paper reports decoding speeds in Table 1:

• Baseline LevT: 263.11 sentences per second (full WMT'14 test set)
• • Constr. Ins.: 260.19 sent/sec
• • No Del.: 260.61 sent/sec
• • No Ins.: 254.64 sent/sec

The differences are within the range of measurement noise (the paper describes them as "no significant difference"). The slight drop for the full constraint suite (+ No Del. + No Ins., 254.64 sent/sec vs. 263.11 baseline) represents a ~3.2% reduction — dramatically smaller than the 3× slowdown reported by Post and Vilar for constrained beam search.

Why the overhead is negligible. The key reasons are architectural:

1. No additional classifier calls. The constraint injection module does not add any new neural network forward passes. The deletion, placeholder, and token classifiers run exactly as in standard LevT — they process the entire sequence in parallel regardless of its content. The mask override is a simple array indexing operation applied after the deletion classifier's logits are computed: it sets the "delete" logit to -∞ for masked positions before the argmax, which is a constant-time vector operation.

2. No increase in sequence length beyond what constraints add. Starting with y_0 already populated with constraints means the first few refinement iterations might actually be shorter (in terms of insertion operations needed) than starting from <s> </s>, because the model doesn't need to insert the constraint tokens from scratch. The total compute is dominated by the Transformer forward passes, which scale quadratically with sequence length (self-attention). If the constraints represent a small fraction of the total output length (the average number of constraints per sentence is 1.15 in the WMT'14 filtered set, with most being single tokens), the sequence length increase is negligible.

3. Mask computation is O(n) and vectorized. Rescanning the sequence to identify constraint token positions costs a single pass over the sequence, comparing each token to the set of constraint tokens. This is implemented as a vectorized operation in the FAIRSEQ framework, not a Python loop, and its cost is dwarfed by the Transformer forward pass (which involves large matrix multiplications).

4. No beam search, no constraint coverage tracking, no hypothesis splitting. This is the fundamental difference from constrained autoregressive decoding. Autoregressive methods must maintain constraint satisfaction state across the beam — tracking which constraints have been completed, which are in progress, and which are not yet started for each hypothesis — and this tracking grows with beam width, vocabulary size, and number of constraints. LevT has no beam: it maintains a single sequence that is iteratively refined. The constraint guarantee is architectural (tokens are forced to stay in the sequence) rather than algorithmic (beam search finds hypotheses that happen to include them), so no tracking is needed beyond the simple mask.

What costs remain. The minor overhead observed (3.2% for the full constraint suite) likely comes from:

• Slightly longer sequences on average (the constraint tokens are additional tokens that the model must process in self-attention), though this is partially offset by the fact that these tokens would need to be inserted anyway in unconstrained decoding.
• The mask recomputation after deletion and insertion (a minor bookkeeping cost).
• The placeholder suppression check (comparing each gap's neighboring tokens to the constraint set — also minor).

The critical point is that none of these costs scale with the number of constraints or the sequence length in a way that would make constrained decoding asymptotically slower than unconstrained. In contrast, constrained beam search methods have overhead that scales with the number of constraint subsets being tracked, which is exponential in the number of constraints in the worst case.

---

Design Choices and Their Justifications

Why Levenshtein Transformer over other non-autoregressive models. The paper implicitly makes this choice by building on LevT rather than alternative NAT architectures like Mask-Predict (Ghazvininejad et al., 2019) or Insertion Transformer (Stern et al., 2019). The justification can be inferred from the architectural properties:

• Mask-Predict generates all tokens in parallel at each iteration, then masks out (replaces with [MASK]) the tokens with the lowest predicted probabilities, and regenerates them in the next iteration. There is no explicit "delete" operation — tokens are regenerated from scratch. This means there is no natural way to guarantee that a constraint token, once present in the sequence, won't be masked and regenerated as something else in a subsequent iteration. You could force the mask to never apply to constraint positions, but this changes the model's inference dynamics (mask-predict relies on remasking to fix errors, and preventing remasking of constraints could leave them in suboptimal positions with incorrect surrounding context that can't be adjusted).

• Insertion Transformer only has insertion operations (no deletion). While you could seed y_0 with constraints similarly to LevT, there is no mechanism to remove extraneous tokens that the model inserts inappropriately, which could lead to the constraint being surrounded by garbage tokens or duplicated content. LevT's deletion classifier serves as an error-correction mechanism that can clean up the model's own mistakes.

• LevT has both insertion and deletion, trained in alternation. The deletion classifier gives an explicit, binary signal at every position that can be cleanly overridden by a mask. The insertion mechanism is flexible enough to add tokens anywhere, including between constraints, before them, and after them. The combination means the model can receive an initial sequence that is both overcomplete (it contains constraint tokens that may be at slightly wrong positions or in an awkward order) and undercomplete (it's missing all the function words, articles, prepositions, etc. that make the sentence grammatical), and the iterative delete-then-insert loop naturally corrects both issues.

Why constrain deletion rather than trusting the model. The paper shows that with only constraint insertion (+ Constr. Ins., no mask), term usage is 94.43% — meaning ~5.6% of constraints are deleted by the model. This happens when the model's learned deletion policy considers a constraint token inappropriate for the source sentence. For example, if the source sentence uses "charge" in the sense of "to demand payment" but the constraint forces the translation "berechnen" (which means "to calculate/invoice"), the model might delete "berechnen" because it doesn't fit the context well. From an MT quality perspective, the model's judgment might be better than the constraint — but from a terminology enforcement perspective, the user's requirement overrides the model's preference. The mask trades some fluency for guaranteed compliance, which is the correct tradeoff in the paper's application domain (regulated terminology).

The paper's ablation in Table 1 quantifies this tradeoff: adding the deletion mask (+ No Del.) increases term usage from 94.43% to 99.62% and improves BLEU on the constrained subset from 29.93 to 30.43. The BLEU improvement suggests that even when the model would prefer to delete a constraint, forcing it to keep it and generate around it produces better translations than letting the model drop the constraint (the reference translations do contain those terms, after all).

Why suppress intra-constraint insertions. Without insertion suppression, the placeholder classifier might insert tokens inside multi-word constraints. For example, with the constraint "Pilot@@ projekt" (the German compound noun "Pilotprojekt"), the model might insert an adjective between the two subword tokens, producing something like "Pilot neues projekt" ("pilot new project"), which breaks the constraint's integrity. The suppression (+ No Ins.) increases term usage from 99.62% to 100% in Table 1, with a very small BLEU improvement (30.43 → 30.49 on the constrained subset). The 0.38% of cases where constraints were broken without suppression likely involved such intra-constraint insertions.

Why constraint order is preserved in y_0. The constraints are inserted in the order they appear in the constraint list: C_1 C_2 ... C_m. The paper does not discuss constraint reordering strategies — the constraints are placed in this fixed order regardless of whether it matches the target-language word order. This is a deliberate simplification justified by empirical observation: for English-German, 97-99% of constraints appear in the same relative order as their source-side correspondents. For language pairs with more divergent word order (e.g., English-Japanese, where verbs move to sentence-final position), this simplification would break down and a reordering strategy would be necessary. The paper acknowledges this limitation in Section 5.3:

"This issue may become more apparent in language pairs with more distinct syntactic differences between the source and target languages."

The rationale for not addressing reordering in this paper is that most terminology database entries are nominal (nouns, noun phrases), which tend to preserve their relative order across languages even when verbal elements move. For example, in an English subject-verb-object sentence with multiple noun phrase constraints, the noun phrases will typically appear in the same order in both languages, even if the verb position differs.

Why no training modification. A central claim of the paper is that the approach "does not require any modification to the training procedure." This is both a practical advantage (any existing LevT model can be used with constraint injection immediately, without retraining) and a conceptual claim (the LevT architecture is naturally suited to this task — the training objective of refining partial sequences already teaches the model the skill that constraint injection requires). Adding constraint-aware training (e.g., training on sequences seeded with constraints) could potentially improve performance further, but the paper demonstrates that it is not necessary to achieve the main goals of 100% term usage and speed parity.

Why greedy decoding (no beam search). LevT uses greedy decoding at each step: the deletion classifier takes the argmax over {keep, delete}, the placeholder classifier takes the argmax over insertion counts, and the token classifier takes the argmax over the vocabulary. There is no beam search, no temperature sampling, and no stochasticity. This is the standard LevT inference procedure and is not changed for constraints. The determinism means that the same source sentence with the same constraints will always produce the same output — a property that is valuable for terminology enforcement (consistency across runs). The lack of beam search also means there is no exponential blowup from constraint tracking across hypotheses, which is what makes autoregressive constrained decoding slow.

4. Key Insights and Innovations

Innovation 1: Reframing Lexical Constraint Enforcement as an Initial State Problem Rather Than a Search Problem

The paper's most distinctive conceptual move is a reframing of the lexical constraint problem that makes its solution almost trivial. Prior work — both constrained training (Song et al., 2019; Dinu et al., 2019) and constrained beam search (Hokamp and Liu, 2017; Post and Vilar, 2018) — treated constraint enforcement as an active control problem: the decoder must find hypotheses that satisfy constraints while the generation process is running. This framing naturally leads to solutions that add machinery to the decoding loop — constraint coverage trackers, hypothesis splitters, finite-state acceptors — all of which add per-step computation because the decoder must continuously check whether constraints are being satisfied and steer generation toward hypotheses that include them.

The paper's insight is to ask a different question entirely: what if constraints are not something the decoder must search for but something it starts with? By populating the initial decoding state y_0 with constraint tokens before the first refinement iteration and then letting the model's normal edit-based refinement process handle the rest, constraint enforcement becomes a problem of state initialization rather than search-time guidance. The model doesn't need to find the constraints — they're already there. It only needs to not remove them and to generate around them, both of which are operations it was already trained to handle.

This reframing is not merely a clever implementation trick. It dissolves the speed-control tradeoff that had been treated as inherent to the problem. Constrained beam search methods had shown that near-perfect term usage was achievable (Post and Vilar, 2018 reached 99.5% on Wiktionary), but always at a 3× or greater decoding slowdown because the search space expanded combinatorially with constraint tracking. The fundamental assumption — that constraints must be achieved through search — went unchallenged because autoregressive generation has no mechanism for "starting with" tokens at arbitrary positions; generation is strictly left-to-right, so constraints can only be arrived at by generating them in sequence.

The LevT architecture enables this reframing because it was designed to operate on partially complete sequences with tokens at arbitrary positions — a capability originally intended for speed (parallel refinement), not controllability. The paper recognizes that this architectural property is independently valuable for the constraint problem, making it a capability transfer rather than a novel mechanism. The evidence for this reframing's power is in Table 1: the gap between baseline LevT (80.23% term usage, constraints appearing only when the model naturally generates them) and + Constr. Ins. (94.43% term usage, constraints seeded in y_0) comes entirely from changing the initial state — no new classifiers, no new training, no decoding modifications beyond populating the starting sequence. The additional bump to 100% comes from the mask overrides, but the bulk of the gain (from 80% to 94%) is purely from initialization.

This reframing also explains why the approach generalizes across languages without language-specific engineering. The English-German and Romanian-English results (Tables 1 and 5) show consistent behavior because the initialization strategy doesn't depend on word order, syntax, or constraint type — it relies entirely on the model's own learned refinement policy, which is language-agnostic (trained on whatever language pair the model targets).

---

Innovation 2: The Deletion Mask as a Minimal Intervention That Preserves Model Agency

A subtler but equally important contribution is the paper's design philosophy for how constraints are enforced: override only the decision to remove, never the decision to place or reorder. This is what the constraint mask (+ No Del.) does — it forces the deletion classifier's output to "keep" at constraint positions while leaving the placeholder classifier and token classifier completely unmodified. The model retains full agency over where to insert tokens around the constraints, how many tokens to insert in each gap, and which tokens to generate. It is only prevented from a single type of action (removing constraint tokens), and only at specific positions.

This is a fundamentally different design philosophy from constrained beam search, which attempts to guide the decoder toward constraint-satisfying hypotheses through modified scoring — effectively telling the model "you should want to generate these tokens." The paper's approach inverts this: it tells the model "these tokens are non-negotiable parts of the output; figure out how to complete the sequence around them." The model is not being steered toward constraints; it is being given constraints as facts and asked to problem-solve around them.

Why this matters: it means the model can use its full learned knowledge of fluency, grammar, and adequacy to integrate constraints naturally. In constrained beam search, the hypothesis space is pruned by constraint coverage, which can force the decoder down paths that satisfy constraints but produce awkward surrounding text — the search prioritizes constraint satisfaction over fluency when the two conflict. In the paper's approach, constraint satisfaction is guaranteed architecturally (the mask prevents removal), so the model's insertion and token prediction decisions are made purely based on what produces the most fluent and adequate completion given the constraints' presence. The model doesn't need to trade off constraint satisfaction against quality — satisfaction is handled separately.

The empirical support for this claim is in Table 1: adding the deletion mask (+ No Del.) improves BLEU on the constrained subset from 29.93 to 30.43 — the forced retention of constraints actually improves translation quality rather than degrading it. This is counterintuitive if you think of constraints as external impositions that the model must work around. The BLEU improvement suggests that the constraints provide useful scaffolding — the model knows these tokens must appear and generates surrounding text that is more target-like because it has more structural information to work with. The ablation in Section 5.3 supports this interpretation: randomly inserting constraints into finished translations drops BLEU from 29.9 to 29.3, while the model's own integration improves it. The model is not just tolerating constraints — it's actively using them to produce better output.

---

Innovation 3: A Negative Result Implicitly Establishing the Boundary of Non-Autoregressive Constraint Methods

The paper's constraint insertion mechanism achieves 94.43% term usage without the deletion mask — a 14.2 percentage point improvement over the baseline LevT's 80.23%. But the remaining ~5.6% failure rate is diagnostically significant. These are cases where the model's deletion classifier, operating normally on the constraint-seeded y_0, chooses to delete one or more constraint tokens. This means the model's learned policy, trained on distillation data without any constraint awareness, considers those tokens inappropriate for the output given the source sentence and surrounding context.

This failure mode is not a bug — it reveals something important about the limits of non-autoregressive constraint enforcement without hard masking. Unlike constrained beam search methods, which can be tuned to balance constraint satisfaction against model probability (e.g., by weighting constraint satisfaction in the beam score), the "soft" version of this approach (+ Constr. Ins. only) delegates entirely to the model's judgment. When the model deletes a constraint, it's making a statement: "in the space of sequences I was trained to produce, this token does not belong here." This could happen because:

• The constraint translation is contextually inappropriate (wrong sense of a polysemous word).
• The constraint's BPE tokenization interacts poorly with the surrounding generated tokens.
• The constraint appears at a position where the model's learned syntax expects a different part of speech.

The significance of this negative result is that it establishes a sharp boundary between soft and hard constraint enforcement in edit-based NAT models. Soft enforcement (seed the constraints, trust the model) provides high but not perfect reliability — suitable for applications where occasional constraint drops are acceptable if the alternative is a bad translation. Hard enforcement (mask deletion, suppress intra-constraint insertions) provides 100% reliability but at the cost of potentially forcing the model to integrate tokens it would prefer to reject — suitable for regulated domains where terminology compliance is non-negotiable.

This boundary is not obvious a priori. One might have expected that seeding constraints in y_0 would effectively guarantee their survival, since LevT's deletion classifier was trained on distillation data where tokens that belong in the final output are present and should be kept. The 5.6% deletion rate shows that the model's notion of "belongs in the output" is not perfectly aligned with the constraint list — a finding that has implications for any future work attempting to use NAT models for controllable generation without explicit enforcement mechanisms.

The paper does not frame this as a "negative result" explicitly, but the ablation in Table 1 serves exactly this diagnostic purpose: it shows what happens when you trust the model versus when you don't, and the gap quantifies the misalignment between the model's learned preferences and the user's terminology requirements.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The primary dataset is the WMT'14 English-German (En-De) news translation task (Bojar et al., 2014), with 3,003 test sentences. A bilingual dictionary of 10,522 entries is constructed by sampling 10% of En-De translation pairs from Wiktionary, and after applying this dictionary to the test set, 454 sentences contain at least one constraint (labeled "Constr." in tables). The average number of constraints per constrained sentence is 1.15, with 220 unique source-side constraint terms. The 500 most frequent English words from a frequency list are filtered out of the dictionary to focus on content words. For comparison against prior work, the paper also uses two WMT'17 En-De test sets released by Dinu et al. (2019), constructed from Wiktionary (727 sentences) and IATE terminology database (414 sentences) entries, where constraints are extracted by exact string matching of source and target dictionary entries in the sentence pairs. An additional WMT'16 Romanian-English (Ro-En) test set (1,999 sentences) is used for cross-language validation, with a dictionary of 3,490 entries sampled from Wiktionary yielding 270 constrained sentences (average 1.11 constraints per sentence, 122 unique source constraints). All datasets are tokenized using Moses tokenization scripts and segmented into subword units using byte-pair encoding (BPE) with 32,000 merge operations for En-De (vocabulary size 39,843) and 40,000 operations for Ro-En (vocabulary size 39,348). The En-De training data consists of 3,961,179 distilled sentence pairs released by Gu et al. (2019); the Ro-En training data is 599,907 sentence pairs.

• Base model(s). The Levenshtein Transformer (LevT) (Gu et al., 2019) with the base Transformer configuration: 6 encoder layers and 6 decoder layers, each with 8 attention heads, model dimension d_model = 512, feed-forward network hidden dimension d_ff = 2048, learned positional embeddings, and tied source-target embeddings. The model is trained using sequence-level knowledge distillation from an autoregressive Transformer base teacher model, following the exact training routine and hyperparameters of the original LevT paper. The base model is not modified or fine-tuned for constraint handling—the architecture is identical across all experiments. The model is chosen because its edit-based iterative refinement loop (alternating deletion and insertion operations) naturally operates on partially complete sequences, which the authors exploit for constraint injection, and because it achieves "substantially higher inference speed compared to beam search without affecting quality."

• Metrics. Two primary metrics are reported: (1) BLEU score (Papineni et al., 2002), the standard machine translation quality metric based on n-gram precision against reference translations, computed separately on the subset of test sentences containing constraints ("Constr.") and the full test set ("Full")—this measures translation quality whether constraints are present or not; (2) Term usage rate (Term%), defined as the number of constraint tokens that appear in the generated output divided by the total number of given constraints—this measures constraint enforcement reliability. A third metric, decoding speed in sentences per second (sent/sec), is reported to verify the "no speed penalty" claim. Statistical significance is assessed using bootstrap resampling (Koehn, 2004) with a threshold of p-value < 0.05 on BLEU score differences.

• Baselines. The paper compares against several baselines: (1) Baseline LevT — the standard unconstrained LevT model with no constraint injection (y_0 = <s> </s>), representing the default behavior where constraints appear only when the model naturally generates them; (2) POST18 — the constrained decoding approach of Post and Vilar (2018) using dynamic beam allocation on a standard autoregressive Transformer, achieving ~99.5% term usage on Wiktionary but with a 3× decoding slowdown (results taken from Dinu et al., 2019); (3) DINU19 — the constrained training approach of Dinu et al. (2019) using code-mixed training data augmentation and factored training on a 2-layer Transformer, achieving 93.4-94.5% term usage; (4) Baseline Transformer — an unconstrained autoregressive Transformer (results from Dinu et al., 2019, used as the reference point for POST18 and DINU19). For the random-insertion analysis in Section 5.3, a random insertion baseline is introduced: constraints not present in the baseline LevT output are randomly placed at arbitrary positions in the translation, achieving 100% term usage but degrading BLEU.

• Generation budget / compute accounting. The paper does not impose a "computation budget" in the sense of constraining the number of refinement iterations or generated tokens to make methods comparable—instead, it compares methods under their default inference configurations and measures the resulting speed in sentences per second. The LevT model's iterative refinement loop runs until convergence (sequence does not change) or a maximum number of iterations is reached (inherited from the original LevT configuration, not explicitly specified). The speed measurement captures the full end-to-end decoding process including all refinement iterations. This is a departure from the "fixed generation budget" methodology common in scaling studies—the paper's fairness argument rests on the empirical observation that constrained LevT converges in approximately the same number of iterations as unconstrained LevT (as evidenced by the near-identical sentences-per-second measurements), so no explicit budget constraint is needed. For autoregressive baselines, speed is inherently tied to target sequence length and beam width.

• Cross-validation / statistical protocol. No cross-validation is reported. The paper uses a single training run on the full training data and evaluates on the fixed test sets. Statistical significance of BLEU score improvements is assessed using bootstrap resampling (Koehn, 2004) with p-value < 0.05, reported for the constrained-subset BLEU improvement in Section 5.2 (the +0.6 BLEU gain on the "Constr." WMT'14 subset is stated to be statistically significant). All other comparisons report raw metric values without confidence intervals or significance tests. The test sets for comparison against prior work (Wiktionary and IATE WMT'17 subsets) are the exact datasets released by Dinu et al. (2019), enabling direct head-to-head metric comparison without statistical testing.

Main Quantitative Results

The results are organized into three groupings: (1) the main English-German experiment with progressive ablation of constraint enforcement mechanisms (Table 1), (2) comparison against prior constrained decoding and constrained training methods on the WMT'17 test sets (Table 3), and (3) cross-language validation on Romanian-English (Table 5, Appendix C).

English-German WMT'14 Results with Constraint Mechanism Ablation

Table 1 presents the primary experiment, comparing four configurations on the WMT'14 En-De test set:

• Baseline LevT: The unconstrained model achieves 80.23% term usage on the constrained subset (454 sentences) and 26.49 BLEU on that subset, with 29.86 BLEU on the full test set. Decoding speed is 263.11 sentences per second. The 80.23% term usage represents the model's natural tendency to generate constraint terms when it considers them appropriate—approximately 4 out of 5 constraints are satisfied without any intervention.

• + Constr. Ins. (constraint insertion into y_0, no masks): Adding constraint insertion with no enforcement mechanisms improves term usage to 94.43% (a 14.2 percentage point gain). BLEU improves slightly to 26.50 on the constrained subset and 29.93 on the full set—these improvements are small because only ~1% of reference tokens are constraint tokens. Decoding speed is essentially unchanged at 260.19 sent/sec. This configuration demonstrates that simply seeding the initial sequence with constraints achieves the bulk of the reliability gain, with the model's learned deletion policy retaining constraints in the vast majority of cases.

• + No Del. (constraint insertion + deletion mask): Forcing the deletion classifier to keep all constraint tokens increases term usage to 99.62%. BLEU improves to 26.59 on the constrained subset (a statistically significant +0.6 BLEU over the baseline, p-value < 0.05) and remains at 29.86 on the full set. Speed stays at 260.61 sent/sec. The BLEU improvement is noteworthy because it contradicts the intuition that forcing a model to retain tokens it would have deleted degrades quality—instead, retention improves it, suggesting the constraints provide useful structural scaffolding.

• + No Ins. (full enforcement: + Constr. Ins. + No Del. + insertion suppression): Adding insertion suppression within multi-word constraints achieves 100% term usage. BLEU reaches 26.60 on the constrained subset and 30.49 on the full set. Speed drops marginally to 254.64 sent/sec (a ~3.2% reduction from the baseline, which the authors describe as not significant). This configuration represents the paper's complete solution: guaranteed constraint presence at near-identical speed and improved translation quality.

The speed results are central to the paper's contribution claim. The largest observed speed difference is between the baseline (263.11 sent/sec) and the full constraint suite (254.64 sent/sec)—an 8.5 sentences-per-second absolute difference, or ~3.2% relative. This is dramatically smaller than the 3× slowdown (200% relative) reported by Post and Vilar (2018) for constrained autoregressive beam search. The authors state there is "no significant difference in the number of sentences decoded per second between the unconstrained and the lexically constrained LevT models."

Comparison Against Prior Work on WMT'17 Test Sets

Table 3 reports results on the two WMT'17 En-De test sets (Wiktionary and IATE) used by Dinu et al. (2019), enabling direct comparison against POST18 (dynamic beam allocation, Post and Vilar, 2018) and DINU19 (code-mixed training, Dinu et al., 2019). All numbers for prior work are taken from Dinu et al. (2019). The results:

On the Wiktionary test set:

• Baseline LevT achieves 81.11% term usage and 30.24 BLEU—substantially higher than the Baseline Transformer (76.90% term usage, 26.00 BLEU), reflecting the LevT architecture's stronger base performance.
• POST18 (DBA): 99.50% term usage, 25.80 BLEU. The DBA method achieves near-perfect constraint enforcement but at lower BLEU than either baseline.
• DINU19 (code-mixed training): 93.40% term usage, 26.30 BLEU. The training-based approach achieves high but imperfect term usage with modest BLEU improvement over the Transformer baseline.
• This work + Constr. Ins.: 93.44% term usage, 30.82 BLEU. At this configuration (no mask), term usage is comparable to DINU19 but BLEU is substantially higher due to the stronger LevT base model.
• This work + No Del.: 98.53% term usage, 31.04 BLEU. Adding the deletion mask achieves higher term usage than both POST18 (98.53% vs. 99.50%) while maintaining a large BLEU advantage.
• This work + No Ins.: 100.00% term usage, 31.20 BLEU. The full constraint suite achieves perfect term usage—matching or exceeding POST18's 99.50%—while BLEU is 31.20 vs. POST18's 25.80 (a +5.4 BLEU gap) and DINU19's 26.30 (a +4.9 BLEU gap).

On the IATE test set:

• Baseline LevT: 80.31% term usage, 28.97 BLEU.
• POST18: 82.00% term usage, 25.30 BLEU. Notably, POST18's term usage drops substantially on the IATE set compared to Wiktionary (82.00% vs. 99.50%), suggesting the DBA method's reliability is dictionary-dependent.
• DINU19: 94.50% term usage, 26.00 BLEU. More consistent term usage than POST18 across dictionaries.
• This work + Constr. Ins.: 93.81% term usage, 29.73 BLEU.
• This work + No Del.: 99.12% term usage, 30.09 BLEU.
• This work + No Ins.: 100.00% term usage, 30.13 BLEU.

The key takeaways from Table 3: (1) the LevT base model is substantially stronger than the Transformer baseline used for prior work (~4 BLEU higher on Wiktionary, ~3 BLEU higher on IATE), so the absolute BLEU comparisons conflate architecture quality with constraint method quality; (2) within the LevT framework, adding constraints (+ No Ins.) improves BLEU over the unconstrained baseline on both test sets (+0.96 BLEU on Wiktionary, +1.16 BLEU on IATE, on the constrained subset or full set depending on how the numbers are computed—the paper reports these as improvements on the constrained subset, but the full-test values from standard BLEU computation would be smaller due to constraint sparsity); (3) the LevT-based method is the only approach that simultaneously achieves 100% term usage and BLEU higher than its own unconstrained baseline; (4) POST18 achieves excellent term usage on Wiktionary but degrades sharply on IATE, while the paper's method is consistent across dictionaries.

Important caveat on the BLEU comparison: The paper notes that the baseline LevT model with 6 layers is "superior to that of Dinu et al. (2019) who used a 2-layer configuration." This means the +0.96 and +1.16 BLEU improvements reported in the abstract and in Table 3 are absolute differences between a strong 6-layer LevT baseline and prior work's 2-layer Transformer-based methods—they are not ablation gains attributable solely to the constraint mechanism. The actual constraint-mechanism gain over the LevT baseline (not over prior work) is the difference between + No Ins. and Baseline LevT within Table 3: on Wiktionary, 31.20 vs. 30.24 (+0.96 BLEU on the constrained test set); on IATE, 30.13 vs. 28.97 (+1.16 BLEU). These are the numbers the paper emphasizes. However, because only ~1% of reference tokens are constraint tokens, BLEU gains of this magnitude on the full test set (3,003 sentences for WMT'14, 727 for Wiktionary, 414 for IATE) are small in absolute terms—Table 1 reports only a +0.1 BLEU improvement on the full WMT'14 test set from the constraint mechanism.

Romanian-English Cross-Language Validation

Table 5 (Appendix C) replicates the En-De experiment on WMT'16 Romanian-English with a LevT model trained on 599,907 sentence pairs:

• Baseline LevT: 80.33% term usage, 33.00 BLEU on the constrained subset, 35.35 BLEU on the full set, 271.32 sent/sec.
• + Constr. Ins.: 95.33% term usage, 33.10 BLEU on constrained, 35.96 BLEU on full, 274.01 sent/sec.
• + No Del.: 98.67% term usage, 33.13 BLEU on constrained, 36.09 BLEU on full, 263.68 sent/sec.
• + No Ins.: 100.00% term usage, 33.13 BLEU on constrained, 36.09 BLEU on full, 264.45 sent/sec.

The pattern replicates the En-De findings: constraint insertion alone captures most of the term usage gain (80.33% → 95.33%), the deletion mask pushes to near-perfect reliability (98.67%), and insertion suppression achieves 100%. BLEU improvements are small (+0.7 on the constrained subset, similar magnitude to En-De's +0.6). Speed remains essentially unchanged (271.32 baseline vs. 264.45 with full constraints—a ~2.5% reduction). The paper states these are "consistent findings" with the En-De experiments.

Ablation Studies and Robustness Checks

Constraint insertion only (no mask enforcement): Removing both the deletion mask and the insertion suppression (+ Constr. Ins. only, Table 1) reduces term usage from 100% to 94.43% on the WMT'14 En-De constrained subset, with BLEU dropping from 30.49 to 29.93. The ~5.6% of constraints that are deleted represent cases where the model's learned deletion policy considers the constraint tokens inappropriate for the output—this quantifies the gap between the model's learned preferences and the user's terminology requirements. The BLEU drop from 30.49 to 29.93 suggests that when constraints are deleted, the resulting translation is slightly worse (the reference does contain those terms), but the small magnitude indicates that most of the BLEU gain comes from the constraints themselves being present in the output, not from improved surrounding context.

Deletion mask only (no insertion suppression): Removing only the insertion suppression while keeping the deletion mask (+ No Del., Table 1) reduces term usage from 100% to 99.62%, with BLEU at 30.43 vs. 30.49 with full constraints. The 0.38% gap to perfect term usage indicates that in a small fraction of cases, the placeholder classifier inserts [PLH] tokens between the subword tokens of a multi-word constraint, which then get assigned real tokens and break the constraint's integrity. The very small BLEU difference (0.06) suggests these cases are rare and their quality impact is minimal.

Lexical constraint dictionary source (Wiktionary vs. IATE): Table 3 shows that the method's term usage is consistent across the Wiktionary and IATE test sets (both reach 100% with full enforcement), while POST18 (DBA) degrades from 99.50% term usage on Wiktionary to 82.00% on IATE—a 17.5 percentage point drop. The paper does not analyze why DBA degrades on IATE, but the consistency of the LevT method across dictionaries supports the claim that constraint enforcement is achieved architecturally (through masking) rather than algorithmically (through search heuristics that may be sensitive to constraint properties).

Language pair (English-German vs. Romanian-English): Tables 1 and 5 show near-identical patterns for En-De and Ro-En across all configurations. Baseline term usage is ~80% for both, constraint insertion reaches ~94-95%, deletion mask reaches ~98-99%, and full enforcement reaches 100%. BLEU improvements on the constrained subset are +0.6 for En-De and +0.7 for Ro-En. Speed changes are 263→255 sent/sec for En-De and 271→264 sent/sec for Ro-En. This cross-language consistency is evidence that the method is language-agnostic—it relies on the model's learned refinement policy rather than language-specific constraint placement heuristics.

Random insertion of constraints into completed translations: Section 5.3 compares the model's constraint integration against a post-hoc baseline where constraints not present in the baseline LevT output are randomly inserted at arbitrary positions. This achieves 100% term usage by construction but causes BLEU to drop from 29.9 to 29.3 on the WMT'14 constrained subset. The paper's method, in contrast, raises BLEU from 29.9 to 30.5. The gap between -0.6 (random insertion) and +0.6 (LevT integration with full constraint suite) demonstrates that the LevT model is not merely retaining constraints but actively generating fluent surrounding text around them—the model's placement and contextual integration of constraints produce better output than the unconstrained baseline, while random placement degrades it.

Word order constraint (deletion mask impact on multi-constraint sentences): Section 5.3 notes that for En-De, 97-99% of target constraints appear in the same order as their source-side counterparts. This means the fixed-order constraint insertion (y_0 = <s> C_1 C_2 ... C_m </s>) is almost always syntactically appropriate. The paper acknowledges this as a limitation: "This issue may become more apparent in language pairs with more distinct syntactic differences between the source and target languages." No experiment with a syntactically divergent language pair (e.g., English-Japanese) is conducted to quantify how often fixed-order insertion degrades quality or forces the model into awkward constructions.

Critical Assessment

Claim: "Our method injects terminology constraints at inference time without any impact on decoding speed." The speed measurements in Table 1 support this claim with a qualification. The baseline LevT achieves 263.11 sent/sec; the full constraint suite achieves 254.64 sent/sec—a ~3.2% reduction. The paper describes this as "no significant difference," which is fair given that prior constrained decoding suffers a 200% (3×) slowdown. However, "without any impact" is slightly overstated—there is a measurable, if small, speed reduction. The weakness is that speed is measured as a point estimate without confidence intervals, standard deviations, or multiple runs, making it impossible to assess whether the 3.2% difference is within measurement noise or a genuine small overhead. Additionally, speed is measured on the full test set, not on the constrained subset—if constrained sentences require more refinement iterations on average (which seems plausible since the model must integrate tokens it didn't choose), the speed parity claim might not hold on constraint-dense inputs. The paper does not report per-sentence iteration counts or speed separately for constrained vs. unconstrained sentences.

Claim: "Our method does not require any modification to the training procedure." Strongly supported. The LevT model used in all experiments is the standard model trained with the original knowledge distillation routine—no constraint-aware training data, no modified loss functions, no architectural changes. The constraint injection mechanism operates entirely at inference time through sequence initialization and classifier output overriding. The Appendix confirms that training hyperparameters (Table 4) are identical to the original LevT paper.

Claim: "[Our approach] improves an unconstrained baseline and previous approaches." Supported with important nuance. The LevT baseline improves by +0.6 BLEU on the WMT'14 constrained subset with full constraint enforcement—a statistically significant gain. The comparison against prior work (Table 3) shows substantially higher BLEU (+4.9 to +5.4 BLEU over POST18 and DINU19 on Wiktionary), but this conflates the LevT architecture advantage (6-layer LevT vs. 2-layer Transformer) with the constraint mechanism advantage. The fair comparison is within the LevT framework—constrained LevT vs. unconstrained LevT. That improvement is +0.96 BLEU on the Wiktionary constrained set and +1.16 on the IATE constrained set—respectable but modest, and attributable largely to the presence of constraint tokens in the output (which match reference tokens) rather than to improved generation of surrounding text. The paper acknowledges that "only 1% of the total reference tokens are constraint tokens," which imposes a hard ceiling on how much BLEU can improve from constraint enforcement alone. A more rigorous improvement claim would separate the BLEU gain into the portion attributable to constraint tokens appearing (a direct consequence of 100% term usage) and the portion attributable to better surrounding context generation (which would indicate that constraints genuinely scaffold better translations). The random insertion analysis partially addresses this—the fact that random insertion drops BLEU while LevT integration improves it suggests the model is doing meaningful integration work—but the -0.6 vs. +0.6 comparison conflates two effects: the quality degradation from randomly placed nonsense insertions and the potential quality improvement from well-placed constraints. A stronger analysis would compare LevT integration against placing constraints at oracle (reference-matched) positions in the baseline output—if LevT still outperforms, that's strong evidence of contextual scaffolding.

Missing experiment: what does the BLEU gain decompose into? A critical analysis that the paper does not perform: measure BLEU on a version of the baseline output where missing constraint tokens are force-inserted at their correct (reference) positions, and compare against the constrained LevT output. This would isolate whether the +0.6 BLEU gain comes from (a) constraints appearing (guaranteed by 100% term usage), (b) constraints appearing at syntactically correct positions (the model's placement skill), or (c) improved generation of non-constraint tokens (genuine scaffolding). Without this decomposition, it's unclear how much of the quality gain is a mechanical consequence of matching reference tokens versus an actual improvement in the translation system's behavior.

Missing experiment: constraint-only BLEU. A related missing analysis: compute BLEU using only the n-grams that contain constraint tokens (or weight those n-grams more heavily). The paper reports that constraint tokens are only ~1% of reference tokens, which means BLEU—which averages n-gram precision across all tokens—is dominated by non-constraint tokens. A 0.6 BLEU improvement on the constrained subset could mask a much larger improvement in constraint-adjacent regions being diluted by unchanged performance on constraint-free portions of the sentence. Analyzing BLEU specifically on spans around constraint positions would provide a more sensitive measure of whether the model integrates constraints naturally.

Missing baseline: constrained autoregressive Transformer with the same 6-layer architecture. The paper compares against POST18 and DINU19, both of which use smaller Transformer configurations (2-layer for DINU19, unspecified for POST18 but from the same era). A fairer comparison would be to implement constrained beam search (DBA or GBS) on a 6-layer autoregressive Transformer trained with the same distillation data, then compare speed, BLEU, and term usage. This would separate the architecture effect (LevT vs. Transformer) from the constraint method effect (initialization + masking vs. beam search modification). The paper does not do this, so the strong BLEU advantage over prior work is confounded.

Test set size and statistical power. The constrained subsets are small: 454 sentences for WMT'14 En-De, 727 and 414 for the WMT'17 Wiktionary and IATE sets, 270 for Ro-En. BLEU differences of 0.6-1.2 points on sets of this size, even when statistically significant by bootstrap resampling, may not be robust. The paper reports only one significance test (the +0.6 BLEU on WMT'14 constrained subset) and does not report confidence intervals or significance for any other comparison. The test sets are fixed (no cross-validation, no multiple random splits), so the reported numbers are point estimates whose variance is unknown.

Multilingual generalizability claim. The paper demonstrates the method on two language pairs (En-De and Ro-En), both of which are Indo-European with relatively similar word order (Subject-Verb-Object for English and Romanian, SOV with V2 word order for German—but the paper notes that 97-99% of constraint terms maintain source order). The claim that the method generalizes to lexically constrained NMT broadly is not tested on more syntactically divergent language pairs (English-Japanese, English-Korean, English-Turkish) where fixed-order constraint placement in y_0 might produce dramatically worse initial states for the model to refine. The paper acknowledges this limitation but does not provide even a qualitative analysis of what would happen—no simulation, no synthetic reordering experiment, no probing of whether the LevT model's refinement policy can recover from severely misordered initial constraint placement.

What would strengthen the paper. (1) Reporting iteration counts per sentence for constrained vs. unconstrained decoding to verify that the refinement process doesn't take more steps when integrating constraints. (2) A per-constraint-length analysis—do multi-word constraints (like "Pilot@@ projekt") get integrated less fluently than single-token constraints? The insertion suppression guarantees they appear intact, but the fluency of the surrounding context might degrade if the model struggles to accommodate longer fixed phrases. (3) A larger-scale evaluation with a more diverse dictionary—the current Wiktionary dictionary is filtered to the 500 most frequent English words removed, meaning the constraints are relatively rare content words that the baseline model often fails on (80% term usage). Performance on high-frequency terms (where the model already generates them ~100% of the time) would not benefit from constraint injection, so the 0.6 BLEU improvement is likely diluted by sentences where the constraint was already satisfied. Reporting results only on sentences where the baseline fails to satisfy at least one constraint would provide a cleaner measure of the method's value. (4) Human evaluation of fluency and adequacy—BLEU is a rough metric that correlates imperfectly with human judgments, especially for small n-gram overlap improvements driven by a few content words. A human study comparing constrained LevT against baseline LevT on the constrained subset would validate whether the BLEU improvement translates to perceptible quality gains.

6. Limitations and Trade-offs

Fixed-Order Constraint Injection Without Reordering Breaks on Syntactically Divergent Language Pairs

The Assumption or Constraint. The constraint injection procedure places constraints into y_0 in the exact order they appear in the user-supplied list: y_0 = <s> C_1 C_2 ... C_m </s>. When the deletion mask is active, constraint tokens cannot be deleted and therefore cannot be moved relative to each other — their order in the final output is locked to their order in the input list. The paper justifies this by observing that for English-German, "97-99% of the target constraints appear in the same order as the source terms" (Section 5.3) and argues that terminology databases mostly contain nominal entries, so "the reordering of lexical constraints boils down to whether the source and target language share the same argument-predicate order."

The Consequence. The method has no mechanism for reordering constraints when the target language syntax demands it. For language pairs where argument order differs substantially — e.g., English (SVO) to Japanese or Korean (SOV), where all noun phrases appearing after the verb in English must move before it in the target — fixed-order constraint placement will produce y_0 sequences that are syntactically impossible to complete fluently. The model's deletion classifier is forced to keep constraint tokens at positions that may be grammatically illegal, and while the insertion mechanism can add tokens around them, it cannot move them. The result would be either ungrammatical output (the model generates around incorrectly positioned constraints) or degraded fluency as the model contorts surrounding text to accommodate a rigid constraint scaffold. The paper explicitly acknowledges this risk: "This issue may become more apparent in language pairs with more distinct syntactic differences between the source and target languages" (Section 5.3). And for the "97-99%" figure — even on English-German, 1-3% of multi-constraint sentences have constraints in a different target order, and the method forces them into source order regardless, likely producing subtle grammatical awkwardness in those cases.

What Evidence Exists in the Paper. None. The paper tests only English-German and Romanian-English — two language pairs with relatively similar argument structure (Romanian is SVO like English; German is SOV in subordinate clauses but V2 in main clauses, though nominal arguments typically maintain similar relative ordering to English). There are no experiments on syntactically divergent language pairs, no simulation study where constraint order is deliberately scrambled to test the model's ability to recover, and no qualitative error analysis of the 1-3% of En-De cases where source and target constraint order differ. The fixed-order assumption is stated as an observation about En-De rather than tested as a robustness dimension.

Mitigation Status. Acknowledged but not addressed. Section 5.3 states: "We will explore potential strategies to reorder constraints dynamically in future work." The paper offers no concrete mechanism for what such reordering would look like — whether it would involve a separate reordering model, source-side syntactic analysis, or relaxing the deletion mask to allow the model's refinement process to permute constraints. Until this is solved, the method's practical applicability is restricted to language pairs where source-target word order for content-bearing nominals is largely isomorphic — which excludes many commercially important translation directions (English↔Japanese, English↔Korean, English↔Turkish, English↔Hindi, among others).

---

Constraint Enforcement Relies on a Model Architecture That Is No Longer the Standard for MT Quality

The Assumption or Constraint. The entire approach depends on the Levenshtein Transformer — a non-autoregressive model that, at the time of this paper's publication, represented state-of-the-art NAT. However, the method is architecturally locked to LevT's specific refinement loop: it requires an explicit deletion classifier (to apply the constraint mask), an explicit insertion mechanism (to add tokens around constraints), and an iterative edit-based decoding process that can start from a partially populated sequence. These mechanisms do not exist in standard autoregressive Transformer models, which dominated MT quality benchmarks at the time and have been further entrenched by subsequent large-scale LLMs (mT5, GPT-4, Claude, etc.).

The Consequence. The method cannot be applied to the dominant MT paradigm. Standard autoregressive Transformers generate tokens strictly left-to-right with no deletion operation, no insertion operation, and no mechanism for starting from a partially populated sequence with tokens at arbitrary positions. The constraint injection technique is therefore inapplicable to the very models that practitioners are most likely to deploy. The LevT model, while achieving "comparable" performance to autoregressive Transformers at the time according to the original LevT paper (Gu et al., 2019), has not become the standard for production MT systems. This means the paper solves the lexical constraint problem only for a specific architecture that has limited adoption outside the NAT research community. The speed-quality tradeoff that the paper claims to eliminate (constraint enforcement without slowdown) is only eliminated within the NAT paradigm — for users of autoregressive models, the speed-control tradeoff documented in prior work (3× slowdown for DBA) remains unsolved.

What Evidence Exists in the Paper. The paper does not compare against a contemporary autoregressive baseline of equal representational capacity. The comparisons in Table 3 are against POST18 (dynamic beam allocation on an unspecified Transformer, results from Dinu et al., 2019) and DINU19 (code-mixed training on a 2-layer Transformer). A fair comparison would implement constrained beam search on a 6-layer autoregressive Transformer trained with the same distillation data and compare speed, BLEU, and term usage against the constrained LevT. This experiment is absent. The paper's BLEU advantage over prior work (e.g., 31.20 vs. 25.80 on Wiktionary) conflates the LevT architecture's base quality with the constraint method's effectiveness — a 6-layer LevT vs. a 2-layer Transformer is not a method comparison. When comparing within the LevT framework (constrained vs. unconstrained LevT), the BLEU improvement is a modest +0.96 on Wiktionary and +1.16 on IATE (Table 3) — these are the genuine constraint-method gains, not the architecture gains.

Mitigation Status. Not addressed. The paper does not discuss portability to other architectures or general principles that could be extracted from the LevT-specific mechanism. The constraint insertion concept — seeding an intermediate representation with required tokens and letting the model complete the rest — has conceptual parallels in masked language model approaches (e.g., generating around fixed [MASK] tokens) and diffusion models, but the paper does not draw these connections or suggest how the technique might be adapted. The method is presented as a LevT-specific solution, and its applicability is gated on the LevT architecture's adoption.

---

The Hard Deletion Mask Limits Flexibility for Multi-Constraint Sentences Where Some Constraints Are Contextually Inappropriate

The Assumption or Constraint. The deletion mask (+ No Del.) forces the model to keep every constraint token regardless of contextual appropriateness. While this achieves 100% term usage (Table 1, Table 3), it eliminates the model's ability to reject a constraint that is genuinely wrong for the given source sentence — e.g., a dictionary entry that maps a polysemous source word to a target sense that does not match the usage in that particular sentence. The paper provides an example (Section 5.2) of this working correctly: the constraint charge → berechnen ("to calculate/invoice") is forced into the translation even when the context uses "charge" in the sense of "to demand a fee," and the constrained output is actually closer to the reference. But this is a single curated example.

The Consequence. In deployment, terminology dictionaries are not always perfectly context-sensitive. A user-supplied glossary might map the English "bank" to the German "Bank" (financial institution) but a source sentence discusses a "river bank" (German "Ufer"). With the deletion mask active, "Bank" will be forced into the translation, producing a potentially nonsensical output — the financial institution term appears in a sentence about rivers. Without the mask (+ Constr. Ins. only), the model's deletion classifier could remove "Bank" and generate the correct "Ufer" — producing a better translation at the cost of violating the glossary. This is a fundamental tradeoff between compliance (guaranteed term usage) and accuracy (appropriate term usage), and the paper's hard masking chooses compliance unilaterally. The paper does not discuss or measure how often forced constraints are contextually inappropriate — the 5.6% of constraints deleted in the + Constr. Ins. configuration (Table 1: 94.43% term usage vs. 100% with masking) are cases where the model would have chosen to delete them. Some fraction of these are likely genuine context mismatches where forcing the constraint degrades translation quality, not just cases where the model's learned preferences differ from the glossary for arbitrary reasons.

What Evidence Exists in the Paper. The BLEU improvement from adding the deletion mask (+ Constr. Ins. at 29.93 vs. + No Del. at 30.43 on the constrained WMT'14 subset, Table 1) suggests that, on average, forcing constraint retention improves rather than degrades quality. But this is an aggregate statistic that could mask a bimodal distribution: many constraints are appropriate and their forced retention helps, while a small number are inappropriate and their forced retention produces noticeably bad output, with the small number being washed out in the BLEU average. The paper does not report worst-case behavior, qualitative analysis of constraint-mismatch failures, or per-constraint-type breakdowns that would separate dictionary entries that are unambiguously context-appropriate from those that are context-sensitive. The single example in Table 2 is a success case; failure cases with contextual mismatch are not shown or analyzed.

Mitigation Status. Not directly addressed. The paper offers the constraint mask as an optional mechanism (+ No Del.), and the soft enforcement variant (+ Constr. Ins. without mask, achieving 94.43% term usage) represents a point on the compliance-accuracy tradeoff curve. But there is no mechanism for adaptive masking — selectively enforcing constraints that are contextually appropriate while allowing the model to reject ones that are not. Such a mechanism would require a confidence score or context-sensitivity detector that the paper does not develop. The two configurations (mask on, mask off) are binary, and the practitioner must choose one globally — either tolerate ~5.6% constraint drop rate or risk forced inclusion of inappropriate terms. The paper frames this as a feature (flexibility to choose) rather than a limitation (inability to have both), but the absence of a principled, per-constraint context-sensitivity assessment means that neither option is fully satisfactory for high-stakes applications.

---

100% Term Usage Comes at a Small But Unevaluated Fluency Cost from Insertion Suppression

The Assumption or Constraint. The insertion suppression (+ No Ins.) prevents the placeholder classifier from inserting [PLH] tokens between the subword tokens of multi-word constraints, keeping each constraint phrase intact. The rationale is that "to keep each constraint intact" (Section 4), the system must prevent the model from inserting tokens inside a constraint like "Pilot@@ projekt" that would break it into "Pilot neues projekt." However, there are legitimate linguistic scenarios where the model might need to insert a token within what the dictionary treats as a single constraint phrase — for example, if the constraint is a noun phrase that needs an adjective inserted for grammatical agreement, or if the BPE tokenization creates an artificial boundary that the model's syntax expects to fill.

The Consequence. The insertion suppression is a rigid constraint on the model's generation that may produce slightly less fluent or grammatically awkward output around multi-word constraints. The model's placeholder classifier was trained to insert tokens wherever they are needed for fluency, and suppressing insertions at intra-constraint boundaries removes the model's ability to adapt the constraint phrase's internal structure to the surrounding syntactic context. In the worst case, the rigid constraint block might behave like a "foreign body" in the translation — grammatically correct as a standalone phrase but forcing the surrounding generated text into slightly awkward constructions to accommodate a phrase whose internal structure cannot be adjusted.

What Evidence Exists in the Paper. The BLEU impact of insertion suppression is very small. Comparing + No Del. (deletion mask only, 30.43 BLEU on WMT'14 constrained) to + No Ins. (full enforcement, 30.49 BLEU, Table 1) gives a +0.06 BLEU difference in favor of full enforcement. On WMT'17 Wiktionary (Table 3): + No Del. at 31.04 vs. + No Ins. at 31.20 — a +0.16 BLEU difference. On IATE: 30.09 vs. 30.13 — +0.04. These differences are tiny and likely not statistically significant. The term usage gains (99.62% → 100% on WMT'14) are also small (the paper doesn't report the exact number, but the gap is only ~0.38% of cases). This suggests insertion suppression rarely activates — most multi-word constraints apparently don't trigger the placeholder classifier to insert tokens internally, either because the model already treats them as atomic or because BPE tokenization produces units that the model's syntax treats as cohesive.

Mitigation Status. Not addressed. The paper presents insertion suppression as a straightforward improvement (100% term usage is better than 99.62%) without analyzing whether the 0.38% of cases where it activates represent genuine fluency corrections that the model should have been allowed to make. A qualitative analysis of the specific examples where insertion suppression makes a difference — showing what the model would have inserted and whether the resulting translation is more fluent or less fluent — is absent. The method treats constraint phrases as inviolable units, which is appropriate for the targeted application (terminology databases where the exact phrase matters) but may occasionally conflict with the target language's morphosyntactic requirements in ways that the BLEU scores are too coarse to capture. A human evaluation of these edge cases would reveal whether insertion suppression introduces subtle disfluencies or is genuinely harmless.

---

Speed Parity Claim Is Measured Only on Aggregates, Not Per-Sentence or Per-Constraint

The Assumption or Constraint. The paper claims "no impact on decoding speed" based on aggregate sentences-per-second measurements: 263.11 for baseline LevT vs. 254.64 for full constraint enforcement on the WMT'14 En-De test set (Table 1) — a ~3.2% difference that the paper describes as "no significant difference." The speed measurement includes all test sentences, both with and without constraints (3,003 total, of which only 454 have constraints).

The Consequence. The aggregate speed measurement masks potential variation in the computational cost of constrained decoding. Two plausible effects are not measured: (1) Per-sentence iteration count variation — sentences with constraints might require more refinement iterations to reach convergence because the model must integrate tokens it didn't choose, which could mean constrained decoding takes longer on constraint-bearing sentences specifically; (2) Constraint-count scaling — the overhead of mask computation and sequence scanning grows with the number of constraints, but the test sentences average only 1.15 constraints each (Section 5.1). For a deployment scenario where some sentences have many constraints (e.g., 5-10 terms from a large domain glossary), the mask computation cost, the additional self-attention computation from longer sequences, and potentially more refinement iterations could produce a meaningful per-sentence slowdown that is invisible in an aggregate measurement dominated by constraint-free sentences. The paper does not report the distribution of iteration counts, the distribution of decoding times, or speed separately for constrained vs. unconstrained sentences.

What Evidence Exists in the Paper. Table 1 reports only aggregate sentences-per-second on the full WMT'14 test set, with no confidence intervals, no per-sentence breakdown, no analysis of iteration count distributions, and no measurement on the constrained subset separately. The Ro-En results (Table 5) show a similar pattern (271.32 baseline vs. 264.45 with full constraints — ~2.5% reduction, also on the full test set of 1,999 sentences with only 270 constrained). The paper does not report measurement methodology — whether speed is measured from a single decoding run, averaged over multiple runs, or computed from total decoding time divided by number of sentences. Without this information, the "no significant difference" claim rests on a point estimate of uncertain reliability.

Mitigation Status. Not addressed. The paper does not discuss the relationship between constraint density and decoding speed, does not report per-sentence timing or iteration counts, and does not analyze whether constrained sentences converge in the same number of iterations as unconstrained ones. The LevT refinement loop terminates either when y_{k+1} = y_k or when a maximum number of iterations is reached. If constrained sentences systematically require more iterations but stay below the maximum, the speed difference would be real but small (adding maybe 1-2 iterations on average). If some constrained sentences hit the iteration maximum before convergence (while unconstrained sentences converge earlier), the quality-speed tradeoff would be more complex — the system might be stopping refinement prematurely on some constrained inputs, producing lower-quality output but maintaining apparent speed parity. None of these dynamics are analyzed.

---

Difficulty Estimation for Constraint Appropriateness Is Absent — No Mechanism for Detecting or Handling Inappropriate Constraints

The Assumption or Constraint. The paper assumes that the constraints provided by the user are appropriate for the source sentence — i.e., that each constraint's target-language form correctly translates the concept that appears in the source. The method's entire mechanism is built around guaranteeing the presence of these constraints, not questioning their validity. In the hard enforcement mode (+ No Del. + No Ins.), constraints are forced into the output unconditionally. The only diagnostic available is the model's deletion classifier behavior in the soft enforcement mode — if it deletes a constraint, that signals the model considers it inappropriate — but this signal is discarded when the mask is active.

The Consequence. In real-world deployment, terminology databases are imperfect. They may contain:

• Sense-mismatched entries: The English "charge" maps to German "berechnen" (to invoice), but the source uses "charge" in the sense of "to rush forward" (German "stürmen").
• Domain-mismatched entries: A medical glossary entry maps "discharge" to "Ausfluss" (bodily discharge) but the source discusses "electrical discharge" (Entladung).
• Outdated or erroneous entries: Human-curated glossaries contain mistakes, and the method provides no feedback loop to flag potentially problematic constraints.

With hard enforcement, these inappropriate constraints will be forced into the translation, producing output that is formally compliant (the term appears) but semantically wrong. The paper provides no mechanism for the system to signal uncertainty, flag potential mismatches, or request human review. The BLEU numbers (Table 1: the +0.6 gain with full enforcement) suggest that on the Wiktionary dictionary, inappropriate constraints are rare enough that force-including them improves average quality — but this is a property of this specific, relatively clean dictionary, not a guarantee for arbitrary user-supplied glossaries.

What Evidence Exists in the Paper. The 5.6% deletion rate in the soft enforcement configuration (+ Constr. Ins., Table 1: 94.43% term usage) is the only evidence of the gap between the model's learned preferences and the user's constraint list. The paper does not categorize what types of constraints get deleted — whether they are contextually inappropriate, poorly translated, or simply rare terms the model doesn't handle well. No qualitative error analysis is provided examining the constraints that the model chooses to delete, which would reveal whether deletions are a feature (the model correcting bad glossary entries) or a bug (the model failing on appropriate but difficult constraints). The paper frames the 94.43% → 100% improvement as unambiguously positive, but some fraction of the 5.6% gap almost certainly represents cases where the constraint is inappropriate and the model's judgment is better than the glossary's.

Mitigation Status. Not addressed. The paper does not discuss constraint validation, confidence scoring, or mechanisms for detecting and reporting potentially problematic constraints. The deletion mask is presented as a feature that guarantees compliance, without acknowledging that compliance to a flawed glossary can produce worse translations than non-compliance. A practical system operating on user-supplied glossaries would need at minimum: (a) a confidence score indicating whether each constraint is contextually appropriate, (b) a mechanism for flagging low-confidence constraints for human review rather than forcing them in, and (c) logging of constraint deletions (in soft mode) or insertion awkwardness (in hard mode) to support glossary quality improvement over time. None of these are discussed or developed. The paper's contribution is purely about enforcement — whether enforcement is always desirable is assumed rather than interrogated.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper shifts the lexical constraint problem from a decoding-time control challenge into an initialization problem — a reframing that dissolves the speed-control tradeoff that had been treated as inherent to constraint enforcement in neural machine translation. This is not a paradigm shift in the Kuhnian sense (it does not overturn the dominant autoregressive paradigm, which remains the standard for production MT), but it is a significant methodological reframing within the non-autoregressive generation literature. Prior work accepted that enforcing constraints meant adding machinery to the decoding loop — constraint coverage trackers, hypothesis-grouping, finite-state acceptors — and that this machinery would monotonically increase decoding time. The implicit assumption was that constraints are something the model must find through search. This paper demonstrates that if you change where constraints enter the generation process (before refinement begins, rather than during it), the search problem collapses into a state initialization problem that the model's existing learned refinement policy can handle with minimal intervention.

The key conceptual move is recognizing that the Levenshtein Transformer's edit-based refinement loop — originally designed for parallel decoding speed — provides a capability that is independently valuable for controllability: the ability to accept a partially complete sequence with tokens at arbitrary positions and refine it into a fluent, complete output. This capability transfer from the speed domain to the controllability domain is the paper's intellectual contribution, and it suggests a broader design principle: architectures that operate by editing or refining partially specified inputs may be more amenable to constraint injection than architectures that generate from scratch. This principle has implications beyond MT — any sequence generation task where users want to specify portions of the output (code generation with required API calls, dialogue with mandatory information, summarization with key facts) could benefit from edit-based architectures that natively handle incomplete initial states.

The paper also reconciles a tension in the prior literature between reliability and speed. Constrained beam search methods (Post and Vilar, 2018) had demonstrated that ~99.5% term usage was achievable on some dictionaries, but at a 3× decoding slowdown. Constrained training methods (Dinu et al., 2019) achieved ~93-95% term usage at normal decoding speed, but with imperfect reliability and a retraining requirement when glossaries changed. The implicit message from prior work was that practitioners must choose between speed, reliability, and flexibility. This paper shows that under a specific architectural choice (edit-based NAT), all three can be achieved simultaneously: 100% term usage, speed parity with unconstrained decoding (~260 sent/sec), and no retraining when glossaries change. The resolution is not that prior methods were flawed — they were optimal within the autoregressive paradigm — but that the paradigm itself imposed the tradeoff.

The paper makes verifier-free constraint enforcement a viable research direction. Prior constrained decoding methods relied on an external verification mechanism (beam search tracking constraint coverage) that ran alongside the model. This verification overhead scaled with the number of constraints and was the primary source of the speed penalty. By embedding constraint enforcement into the model's own refinement process (the deletion mask overrides a classifier that was already running), the paper eliminates the external verifier entirely. This is analogous to the shift in other areas of ML from post-hoc verification (generate, then check) to architectural guarantees (the model cannot violate the constraint by construction). The implication is that future work on controllable generation should look for architectures where constraints can be enforced through structural interventions on the model's own operations rather than through external filtering or re-ranking.

Finally, the paper recalibrates expectations about the BLEU upside of constraint enforcement. The finding that constraints constitute only ~1% of reference tokens, and that 100% term usage yields a BLEU improvement of only +0.6 to +1.2 points on the constrained subset (and essentially zero on the full test set), is an important reality check. Lexical constraint enforcement primarily solves a compliance and consistency problem, not a translation quality problem. The quality gains are modest because the model was already generating most constraint tokens correctly (~80% baseline term usage), and BLEU — dominated by function words and high-frequency n-grams — is insensitive to the presence or absence of a few content words. This suggests that the value of constraint enforcement should be evaluated on domain-specific metrics (terminology consistency, brand compliance, legal accuracy) rather than on general-purpose BLEU, and future work should develop evaluation frameworks that are sensitive to the actual use case.

Follow-Up Research This Work Enables

Reordering-aware constraint injection for syntactically divergent language pairs. The paper explicitly acknowledges that fixed-order constraint placement in y_0 works for English-German because 97-99% of constraint terms maintain source order, but will fail for language pairs where the target syntax demands a different order (e.g., English SOV structure for Japanese or Korean). A strong follow-up would develop a lightweight reordering module that permutes the constraint list before populating y_0 — perhaps using source-side dependency parses to predict target-side argument order, or training a small classifier on parallel data to predict constraint permutation. The key experiment would be to test on English-Japanese or English-Turkish with a terminology dictionary, measuring whether reordered constraint injection recovers the 100% term usage and fluency levels observed for English-German. The specific baseline would be fixed-order injection (which should fail catastrophically on these language pairs), and the ablation would compare reordering via linguistic rules vs. learned reordering vs. relaxing the deletion mask to let the LevT refinement process permute constraints naturally (measuring whether the model's edit operations can recover from misordered initial placement without explicit reordering).

Combining constraint injection with constrained training for harder constraints. The paper demonstrates that inference-time constraint injection works without any constraint-aware training, but the 5.6% deletion rate in the soft enforcement configuration (+ Constr. Ins. only, Table 1) indicates a gap between the model's learned preferences and the user's glossary. A natural extension is to fine-tune the LevT model on constraint-seeded training data — construct training examples where y_0 is populated with target-side terminology from a parallel dictionary, train the model to refine these seeded sequences to match the reference, and measure whether this reduces the gap (improving soft-enforcement term usage toward 100% without hard masking) and improves the fluency of constraint integration (higher BLEU under hard enforcement). The key experiment would compare the fine-tuned model against the inference-only approach on both in-dictionary constraints (seen during training) and out-of-dictionary constraints (novel at test time) to measure whether the training benefit generalizes or is specific to the training glossary.

Adaptive masking with per-constraint confidence estimation. The hard deletion mask forces 100% compliance at the cost of potentially forcing inappropriate constraints (e.g., sense-mismatched glossary entries) into the output. A follow-up could develop an adaptive masking policy that uses the deletion classifier's logit at each constraint position as a confidence signal: if the model strongly predicts "delete" for a constraint token (high confidence that it doesn't belong), the system could flag that constraint for human review or apply a softer penalty rather than forcing retention. The experiment would measure the tradeoff curve between term usage and translation accuracy on a deliberately noisy glossary (artificially corrupted with sense-mismatched entries), comparing hard masking (100% term usage, potentially degraded accuracy), soft enforcement (94.43% term usage, better accuracy on mismatches), and adaptive masking at various confidence thresholds. The ideal outcome is a method that achieves near-100% term usage on appropriate constraints while gracefully degrading (allowing deletions) on genuine mismatches — recovering the compliance-accuracy tradeoff as a tunable parameter rather than a binary choice.

Cross-architecture generalization of constraint initialization. The paper's mechanism is specific to LevT, but the principle (seed an intermediate representation with constraints and let the model refine around them) could generalize. A follow-up could explore constraint injection in other iterative refinement architectures: mask-predict models (where constraints could be placed as unmaskable tokens in the initial sequence, analogous to the deletion mask), diffusion language models (where constraints could be fixed during the denoising process), or even autoregressive models with infilling capabilities (where constraints could be placed and the model generates the gaps). The specific experiment would implement constraint injection in at least one non-LevT iterative model, measure term usage and speed against the LevT baseline, and identify what architectural properties are necessary for the initialization trick to work — is it the explicit deletion classifier, the iterative refinement, the ability to start from partial sequences, or some combination?

Large-scale evaluation on production terminology databases with human judgment. The paper evaluates on clean, research-standard dictionaries (Wiktionary, IATE) with relatively small test sets (414-727 constrained sentences). A deployment-oriented follow-up would partner with an organization that maintains a large, real-world terminology database (e.g., an E-commerce platform with product name glossaries in 20+ languages, or a legal translation service with defined-term dictionaries) and run a human evaluation comparing constrained LevT output against unconstrained output on metrics that matter to that organization: terminology consistency (do the right product names appear?), translation acceptability (would a human translator accept the output as-is, with minor edits, or needing major revision?), and time saved vs. human post-editing. The key numbers would be: what fraction of constrained translations are directly usable without human correction, how that compares to unconstrained translations, and whether the time savings from eliminating manual terminology checking outweigh any quality degradation from forced constraints. This would ground the method's practical value in concrete workflow metrics rather than BLEU points.

Stress-testing the iteration budget under high constraint density. The paper measures aggregate speed with an average of 1.15 constraints per sentence, but does not analyze whether per-sentence iteration count increases with constraint count. A diagnostic follow-up would systematically vary constraint density (1, 2, 5, 10 constraints per sentence) on a synthetic test set constructed from source sentences with many matchable dictionary entries, measure the number of refinement iterations to convergence and the per-sentence decoding time, and determine whether there is a constraint-count threshold beyond which the speed penalty becomes meaningful. The experiment would also measure whether insertion suppression becomes more active at high constraint density (more multi-word constraints, more intra-constraint gaps that the model wants to fill), potentially revealing a fluency degradation that is invisible at low constraint density. This would establish the operational envelope of the method — how many constraints can be injected before speed or quality meaningfully degrade.

Practical Applications and Downstream Use Cases

E-commerce product localization with brand name enforcement. The paper's opening example — a Chinese-English NMT system translating "红米" as "red rice" instead of "Redmi" — is the canonical use case. An E-commerce platform operating across 20+ language pairs maintains a master glossary of product names, brand terms, and legal disclaimers that must appear verbatim in all translations. With the proposed method, the platform can deploy a single LevT model per language pair, inject the relevant glossary entries for each product listing at inference time (no per-glossary retraining), and guarantee that "Redmi," "iPhone 15 Pro Max," and "30-day return policy" appear exactly as specified in every translation. The 260 sent/sec throughput means the system can handle high-volume product catalog updates without a dedicated terminology post-processing step. The 100% term usage eliminates the risk of brand name corruption that can occur with unconstrained NMT (~20% of constraints missed per Table 1 baseline), and the BLEU improvement of +0.6 on constrained sentences indicates that enforcing terminology does not degrade surrounding text quality.

Regulated industry translation with mandatory terminology compliance. In medical device documentation, pharmaceutical labeling, and legal contracts, specific terms carry regulatory weight — "indication" vs. "intended use," "force majeure" vs. "act of God," "adverse event" vs. "side effect." Regulatory bodies require consistent terminology across all translations, and audits check for exact term matches. The proposed method enables a compliance workflow where the regulated terminology list is injected as constraints, the translation is generated with guaranteed term inclusion, and the output can be programmatically verified to contain all required terms (since 100% term usage eliminates the need for post-hoc constraint checking). The LevT architecture's determinism (greedy decoding, no sampling) means the same source + constraints always produces identical output — a property valuable for audit trails and regulatory submissions where reproducibility matters. The speed parity with unconstrained decoding (~254 sent/sec with full constraints) means compliance does not slow down the translation pipeline, which is critical for time-sensitive submissions like adverse event reports or patent filings.

Terminology-consistent technical documentation across product versions. Organizations maintaining technical documentation (user manuals, API references, specifications) in multiple languages face a consistency challenge: when a product name or technical term changes (e.g., "Admin Console" becomes "Management Dashboard"), all translations must be updated consistently. With constrained training approaches, the model would need retraining for each terminology update. With the proposed method, the updated glossary is simply loaded at inference time — no model changes needed. A documentation team can maintain a versioned glossary per product release, run the same LevT model with the version-appropriate constraint list, and produce translations where the new term appears consistently everywhere. The method's ability to handle multi-word constraints without intra-constraint insertion (enabled by + No Ins.) is particularly valuable here, since technical terms are often multi-word phrases ("network attached storage device," "single sign-on authentication") that must remain intact.

When to Prefer This Method

The paper positions its approach against two alternatives — constrained beam search (POST18) and constrained training (DINU19) — and the decision boundaries emerge clearly from the empirical results:

• Prefer the LevT constraint injection method when: (1) you are already using or willing to adopt a Levenshtein Transformer for NMT — the method requires no additional training and imposes no speed penalty; (2) perfect term usage (100%) is a hard requirement and you want to guarantee it architecturally rather than probabilistically (constrained training achieves only 93-95%, Table 3); (3) decoding speed matters and you cannot tolerate the 3× slowdown of constrained beam search; (4) your terminology glossary changes frequently (new products, updated terms) and retraining is impractical — the method works with any dictionary at inference time with no model modification needed; (5) you are translating between languages with similar argument order for content-bearing nominals (e.g., English-German, English-Romanian) where the 97-99% constraint order preservation assumption holds.

• Prefer constrained beam search (POST18/DBA) when: (1) you are committed to an autoregressive Transformer architecture and cannot switch to a non-autoregressive model — DBA is the best available method within the autoregressive paradigm; (2) you need constraint reordering for syntactically divergent language pairs and the DBA's search-based approach can naturally handle target-language word order differences while the fixed-order LevT initialization cannot; (3) your maximum acceptable term usage is slightly below 100% (POST18 achieves 99.5% on Wiktionary, Table 3) and you want to avoid the potential fluency cost of hard masking force-including inappropriate constraints that the model would prefer to reject.

• Prefer constrained training (DINU19) when: (1) your glossary is static and retraining is a one-time cost you can amortize over high inference volume; (2) you want a balance of moderate term usage (93-95%) without decoding-time overhead within the autoregressive framework; (3) the LevT architecture is not available to you and you need a solution that works with standard Transformer tooling without custom decoding logic.

The critical boundary condition that the paper itself articulates is the language pair constraint: "This issue may become more apparent in language pairs with more distinct syntactic differences between the source and target languages" (Section 5.3). For English-Japanese, English-Korean, or other pairs where source and target argument order differ systematically, the fixed-order constraint injection will produce y_0 sequences that are syntactically impossible to complete fluently, and neither the deletion mask nor the insertion mechanism can fix this — the model cannot move tokens it is forced to keep. In these settings, constrained beam search remains the only viable option among existing methods until a reordering mechanism for constraint injection is developed.