Bridging the Formalization Gap in Software Engineering

28 concepts29 papers1 proposal

Formal methods offer a powerful promise: the ability to mathematically prove that a system is safe, secure, and correct. However, a persistent "formalization gap" prevents these techniques from seeing widespread industrial adoption. As Kabra et al. observe, while we can prove a robot will behave safely once it is modeled, the act of writing that initial mathematical model is a grueling, expert-level task. This research direction focuses on automating the translation between informal requirements, high-level designs, and the rigorous languages required by formal verification tools.

The Manual Translation Bottleneck

The core problem is that software engineering typically begins with informal artifacts: natural language requirements, RFC documents, or architectural diagrams. To use a model checker or a theorem prover, a human must manually translate these ideas into specialized logic. Balzer et al., Goldman et al., and Wile identified this as a major bottleneck as early as 1977, noting that manual formalization requires humans to resolve ambiguities and suppressed context that machines cannot inherently understand.

This manual step is not just slow; it is dangerous. Kwiatkowska et al. and Leitner-Fischer et al. argue that manual translation often introduces modeling errors. If the model being verified deviates from the actual design or code, the resulting safety guarantees become invalid. In safety-critical domains like medical devices, Gunter et al. found that the process of translating English requirements into math is where most inconsistencies and gaps are first discovered, yet the reliance on subjective human interpretation remains a primary point of failure.

Automating the Path to Verification

To close this gap, researchers have developed frameworks that act as automated bridges between different levels of abstraction. These approaches generally fall into three categories:

1. Natural Language to Formal Logic

Modern approaches increasingly leverage Large Language Models (LLMs) to handle the inherent ambiguity of human speech. Merenstein et al. introduced the SpecNFS dataset to benchmark how well models can extract formal logic from technical documents. Similarly, Zheng et al. developed ParCleanse, which uses LLMs to extract "traceable" oracles from RFCs, allowing developers to link specific code bugs directly back to the violated section of a natural language standard. In the realm of statistics, Domke demonstrated that LLMs can serve as a "prior" over models, translating informal descriptions into executable Bayesian programs.

2. Architectural Models to Model Checkers

Engineers often use semi-formal tools like UML or SysML to design systems. Leitner-Fischer et al. show that by automating the translation of these annotated UML models into formal logic, architects can perform safety assessments without being experts in formal methods. Similarly, Sun et al. created a framework to automatically convert Mediator models—used for hierarchical systems—into the language used by the PRISM model checker, ensuring that the high-level design and the verified model remain consistent.

3. Bridging Specification and Implementation

A common failure point is the disconnect between a verified proof and the final executable code. Wang et al. addressed this in networking by using declarative languages as an intermediary, allowing for "correct by construction" protocols where the code is automatically generated from the proof. Without this link, as Intana et al. point out, the manual mapping of high-level specs to low-level simulation or deployment code remains a labor-intensive source of human error.

Why Automation Works

The shift toward automated translation works by reducing the "semantic distance" a human must travel. By providing domain-specific languages (DSLs) or automated compilers, the cognitive load is shifted from the human to the tool. For example, Plotnikov et al. show that a specialized modeling language for neurons allows researchers to write 20 times less code by automating the derivation of complex differential equations.

Ultimately, the goal is to make formal verification a transparent part of the engineering workflow. As Engels et al. demonstrated, once the translation is automated, even tools like model checkers can be repurposed into engines for automated test generation, turning the "burden" of formalization into a powerful asset for system reliability.

Key Foundational Work

Meta-Evaluation as a Tool for Program Understanding (1977) — contributed 1 concept elements to this direction.
Test Generation for Intelligent Networks Using Model Checking (1997) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_manual_specification_translation_01d010bb,
  title = {manual specification translation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/manual-specification-translation/rdr_01d010bbde7e469d95a686bdf96e0e93},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_manual_specification_translation_01d010bb_v1,
  title = {manual specification translation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/manual-specification-translation/rdr_01d010bbde7e469d95a686bdf96e0e93/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake