Specification-Guided Translation

• Specification-guided translation is a formal approach that conditions outputs on explicit user or analytical specifications to meet goal-driven constraints.
• It integrates methods like prompt engineering, multi-modal spec generation, and iterative human post-editing to enhance translation accuracy and functional adequacy.
• Empirical studies show reduced error metrics, improved pass@k in code translation, and higher subjective quality in professional machine translation.

Specification-guided translation is a formalized approach to translation—across natural language, formal logic, and source code domains—in which translation outputs are conditioned on explicit, user-provided or analytically derived specifications that encode communicative goals, correctness criteria, or structural constraints. This paradigm operationalizes the functionalist insight that translations are not evaluated for quality in the abstract, but relative to goal-driven specifications that can encode purpose, audience, legal/compliance needs, or formal behavioral properties. Across professional machine translation, automated code migration, and requirements engineering, research demonstrates that integrating crisp specifications into both generation and evaluation markedly improves the alignment, reliability, and functional adequacy of translation outputs (Kayano et al., 22 Sep 2025, Nitin et al., 2024, Ma et al., 19 Dec 2025, Zhang et al., 2024, Wang et al., 2022, Rabbi et al., 7 Dec 2025, Saha et al., 2024).

1. Theoretical Models for Specification-Guided Translation

Historically, translation was evaluated under the equivalence paradigm, which sought maximal preservation of source meaning or form. This approach is operationalized using reference-based metrics such as BLEU, METEOR, or COMET that quantify token/string or semantic overlap between system outputs and human references. In contrast, functionalist models position each translation as a communicative act determined by its Skopos (purpose), where domain-specific specifications define functional requirements (Kayano et al., 22 Sep 2025). Formally, a translation specification may be abstracted as a set $S = \{g_1, g_2, \ldots, g_k\}$, where each $g_i$ is a goal or constraint.

The specification-guided translation process is thus modeled as:

$T^* = \arg\max_{T \in \mathcal{C}(X)} U_S(X, T)$

where $\mathcal{C}(X)$ is the candidate translation space and the utility function $U_S(X, T)$ measures alignment with the specification set $S$. In neural and LLM-based settings, the search over $\mathcal{C}$ is often replaced with direct generation conditioned on the concatenation of input $X$ and specification $S$:

$$T = f_\theta(\textrm{“Translate X under conditions S”})$$

Both in professional translation (Kayano et al., 22 Sep 2025) and in automated code translation (Nitin et al., 2024, Rabbi et al., 7 Dec 2025, Saha et al., 2024), this functional approach enables the model to prioritize adequacy not in terms of minimum error with reference translations, but in terms of fulfilling explicit functional or behavioral requirements.

2. Workflow Architectures and Modalities

Specification-guided translation is realized using a combination of architectural and workflow strategies that operationalize the specification at different stages:

• Professional MT Workflow:

1. Specification definition (purpose, audience, tone, constraints).
2. Prompt construction combining source and specifications.
3. LLM-based first-draft generation.
4. Human-in-the-loop review and targeted post-editing for spec violations.
5. Dual-track evaluation (error-based, user-preference ranking); optional automatic metric for quick feedback (Kayano et al., 22 Sep 2025).

• Code Translation Pipelines:
  • Multi-stage architectures such as SpecTra (Nitin et al., 2024) and BabelCoder (Rabbi et al., 7 Dec 2025) leverage:
  • Generation of multi-modal specifications (pre/post-conditions, test cases, NL descriptions).
  • Specification validation (self-consistency filtering).
  • Prompt engineering to interleave code with specs for LLM translation.
  • Test-driven refinement and iterative repair based on specification-alignment.
• Requirements Engineering:
  • Hierarchical semantic decomposition (as in Req2LTL (Ma et al., 19 Dec 2025)) where NL requirements are first mapped to a structured intermediate specification (OnionL), which is then deterministically synthesized into the target formalism (LTL).
• Fragmentation and Local Specification:
  • Partitioning of large artifacts (e.g., codebases in Oxidizer (Zhang et al., 2024)) enables localized specification-guided translation at the function/type level using feature mapping and type/I-O equivalence checks.

Table: Representative Modalities by Domain

Domain	Specification Modalities	Alignment Target
Professional MT	Purpose, audience, tone, terminology, format	User/Client intent
Code Translation	Pre/post/IO specs, NL pseudocode, unit tests	Functional correctness
Req. Engineering	Semantic role decomposition, logical grammar	Formal property (LTL/STL)

3. Specification Types and Encoding Methods

Natural Language and Formal Specifications

Professional translation employs specifications encoding communicative intent (purpose, audience), stylistic choices, and client priorities, often adhering to industry standards such as ISO 17100 (Kayano et al., 22 Sep 2025). In code translation, specifications are multi-modal, including:

• Static formal specs: Pre-conditions, post-conditions, type signatures.
• Dynamic/behavioral specs: I/O test cases, execution traces.
• Natural language descriptions: Line-by-line pseudocode, summaries (NL-specs).

SpecTra (Nitin et al., 2024) generates multiple specification modalities per translation instance; BabelCoder (Rabbi et al., 7 Dec 2025) refines specifications through alignment with binary test outcomes.

Formal Intermediate Representations

In formal requirements translation, intermediate representations such as OnionL trees (Ma et al., 19 Dec 2025) or concept-specification graphs (Connor, 2018) act as canonicalized, structured specifications that can be systematically mapped to target formalisms (LTL, STL).

Constrained Decoding and Hard Specifications

Certain constrained decoding strategies (e.g., Prefix Suffix Guided Decoding—PSGD (Wang et al., 2022)) treat user-provided constraints (prefixes, suffixes, terminology) as formal specifications, enforcing them as hard decoding constraints in the candidate space.

4. Evaluation Methodology and Metrics

A hallmark of specification-guided translation is the integration of specification-conditioned metrics into both automatic and human evaluation:

• Professional MT: Weighted MQM error scoring is specialized per specification; severity weights and custom error categories (accuracy, style, conventions) quantify deviation from specification (Kayano et al., 22 Sep 2025).
• Dual Human Evaluation: Combines error-based annotation and subjective end-user preference (clarity, persuasiveness, tonal alignment); statistical aggregation (Wilcoxon signed-rank) confirms significance of preference.
• Reference-Free Automatic Metrics: Metrics such as COMETKiwi are deployed but currently align more closely with formal equivalence than with functional adequacy; discrepancies between metric-based and human eval persist (Kayano et al., 22 Sep 2025).
• Code Translation: Primary metric is pass@k—the probability that at least one of k generated outputs compiles and passes all relevant test cases (Nitin et al., 2024, Saha et al., 2024). Additional metrics include computational accuracy (exact STDOUT/return value match), static code analysis for quality (e.g., SonarQube severe issues (Saha et al., 2024)), and property-guided semantic checks (Eniser et al., 2023, Zhang et al., 2024).
• Formal Properties: In advanced code translation, k-safety semantic properties are directly specified and tested via automated harnesses; property-guided search reduces post-translation violation rates (Eniser et al., 2023).

5. Empirical Results and Comparative Performance

Across both language and code domains, systematic empirical studies demonstrate consistent and sometimes substantial gains from specification-guidance:

• Professional MT (Japanese→English): On investor-relations data, LLM outputs guided by explicit specifications yielded lower MQM error scores (0.38–0.70 vs. 2.60 for official human translation) and better user rankings. All differences were statistically significant except for the closest-performing method pairs (Kayano et al., 22 Sep 2025).
• Code Translation:
  • SpecTra yielded up to 10 percentage points and 26% relative improvement in pass@k across LLMs and language pairs (C→Rust, C→Go, JS→TS) (Nitin et al., 2024).
  • BabelCoder improved computational accuracy by 0.5–13.5 percentage points across four major code translation benchmarks, with performance exceeding all baselines in 94% of settings (Rabbi et al., 7 Dec 2025).
  • Property-guided search improved property satisfaction in code translation by ≈ 20 percentage points (Eniser et al., 2023).
  • NL-spec as an intermediate representation alone was not superior to code-only translation, but its union with source code improved pass@1 in some settings, especially for Python/C++ origins (Saha et al., 2024).
• Scalable Project Translation: Partitioning and specification-guidance at function/type level enabled average I/O equivalence of 73% on large-scale Go→Rust migration—more than doubling prior state-of-the-art (Zhang et al., 2024).
• Formal Requirements: Req2LTL achieved 88.4% semantic accuracy and 100% syntactic correctness in NL→LTL translation on aerospace requirements, surpassing prior methods by >20 points on semantic match (Ma et al., 19 Dec 2025).

6. Strengths, Limitations, and Open Challenges

Strengths of specification-guided translation include systematic error reduction, functional/semantic adequacy, and enhanced traceability in high-stakes domains. Its modularity enables adaptation across MT, code, and formal logic tasks, leveraging prompt engineering, intermediate representations, and multi-agent architectures.

However, limitations persist:

• Spec Generation Reliability: Automated NL-spec or formal spec generation is sensitive to model hallucinations or misinterpretations, propagating faults into translations if not robustly validated (Saha et al., 2024).
• Evaluator Bottlenecks: Manual MQM annotation imposes cost/scaling limits (Kayano et al., 22 Sep 2025).
• Incomplete Coverage: LLMs struggle with deeply nested logical structures, implicit/ambiguous semantics, or domain-specific temporal constraints (e.g., in NL→LTL) (Ma et al., 19 Dec 2025).
• Metric Misalignment: Automatic metrics may not capture task-specific adequacy, penalizing even superior spec-guided outputs if reference overlap is low (Kayano et al., 22 Sep 2025).
• Scalability: While partitioned approaches scale translation to larger codebases, cross-fragment dependencies, context window constraints, and function mocking are nontrivial obstacles (Zhang et al., 2024).

Research directions include LLM-based auto-evaluation (“LLM as Judge”), integration of static analysis and symbolic execution, expansion to richer logics (e.g., Metric Temporal Logic), and improvement of automated spec extraction/generation.

7. Domain Breadth and Generalization

Specification-guided translation is not specific to any single translation scenario but rather generalizes:

• Across modality (linguistic, code, formal requirements).
• Across domains (investor communications, safety-critical verification, codebase migration).
• Across workflow types (fully automated, semi-automated with human oversight, interactive translation suggestion with hard constraints) (Kayano et al., 22 Sep 2025, Wang et al., 2022, Ma et al., 19 Dec 2025).

A central implication from comparative studies is that the quality of specification guidance directly governs output adequacy—underscoring the necessity of robust specification engineering (explicit, comprehensive, validated) in professional, scientific, and engineering translation workflows.

---

References:

• Kayano & Sugawara, "Specification-Aware Machine Translation and Evaluation for Purpose Alignment" (Kayano et al., 22 Sep 2025)
• Joshi et al., "SpecTra: Enhancing the Code Translation Ability of LLMs by Generating Multi-Modal Specifications" (Nitin et al., 2024)
• Wang et al., "Easy Guided Decoding in Providing Suggestions for Interactive Machine Translation" (Wang et al., 2022)
• Saha et al., "Specification-Driven Code Translation Powered by LLMs: How Far Are We?" (Saha et al., 2024)
• Eniser et al., "Automatically Testing Functional Properties of Code Translation Models" (Eniser et al., 2023)
• Ivanov et al., "Scalable, Validated Code Translation of Entire Projects using LLMs" (Zhang et al., 2024)
• Macedo et al., "BabelCoder: Agentic Code Translation with Specification Alignment" (Rabbi et al., 7 Dec 2025)
• Geng et al., "Bridging Natural Language and Formal Specification--Automated Translation of Software Requirements to LTL via Hierarchical Semantics Decomposition Using LLMs" (Ma et al., 19 Dec 2025)
• Connor, "A Concept Specification and Abstraction-based Semantic Representation: Addressing the Barriers to Rule-based Machine Translation" (Connor, 2018)