Opening — Why this matters now
Natural language is where most software failures quietly begin. Requirements are written in good faith, read with confidence, and implemented with subtle misunderstandings that only surface once systems are deployed, audited, or—worse—regulated. The uncomfortable truth is that natural language is flexible where engineering systems demand rigidity.
This paper tackles that gap head‑on, proposing a method where formal logic leads and language follows. Instead of writing requirements first and wrestling semantics into place later, the authors invert the workflow: start from formal specification patterns, then systematically generate a controlled natural language (CNL) using an AI assistant. Precision first. Fluency second.
Background — Context and prior art
Controlled Natural Languages are not new. They have long promised unambiguous requirements that humans can read and machines can verify. The problem is trade‑offs. Existing approaches usually land in one of two uncomfortable camps:
| Approach | Strength | Weakness |
|---|---|---|
| Expressive CNLs (e.g. SysReq) | Rich, flexible descriptions | Complex, unwieldy formal semantics |
| Simple pattern languages | Clean formal logic | Severely limited expressiveness |
Many industrial frameworks follow a linguistics‑first path: define a readable language, then retroactively map it to logic. Unsurprisingly, semantics become bloated, brittle, or incomplete. This paper instead follows a semantics‑first discipline—formal patterns already exist, so the language should conform to them, not the other way around.
Analysis — What the paper actually does
The authors present a three‑stage method for constructing a CNL from any formal specification pattern whose attributes admit simplification under constant values.
Stage 1: The base pattern
A single, maximally expressive natural‑language template is written manually. This base sentence explicitly references all attributes of the formal pattern, even if that makes it verbose. Think of it as the “superset sentence.”
Example (event‑driven temporal logic):
After trigger, invariant is valid until either release or reaction, and reaction must occur within delay from final.
At this stage, elegance is irrelevant. Coverage is everything.
Stage 2: Derived patterns via AI assistance
Here the AI assistant earns its keep. By partially evaluating attribute values (true / false / variable), the formal logic simplifies—and so should the language. The AI is prompted to reformulate the base sentence accordingly.
Crucially, the authors discover that how you prompt matters more than whether you prompt:
- Pure paraphrasing leads to semantic drift.
- Forcing full logical translation produces unreadable prose.
- The sweet spot is reached by explaining the meaning of constant attributes, not by dumping formulas.
This step yields a compact, semantically faithful corpus of requirement sentences—each one logically grounded by construction.
Stage 3: Grammar extraction
Because all derived sentences originate from a single base pattern and are generated under consistent constraints, their grammatical structure is strikingly uniform. This makes grammar induction almost mechanical.
The result is a controlled grammar where:
- Terminal symbols are fixed phrases.
- Non‑terminals correspond cleanly to pattern attributes.
- Every valid sentence has a formal semantics by design.
No post‑hoc alignment. No interpretive guesswork.
Findings — What works, what breaks
The experiments—run on Event‑Driven Temporal Logic (EDTL) and validated against the SUP industrial pattern—surface several practical insights:
| Observation | Implication |
|---|---|
| Some attribute combinations yield unclear language | These combinations are also unclear to humans and should be excluded |
| Adding formal formulas to prompts over‑constrains output | LLMs start “translating logic” instead of refining language |
| Explaining constant attribute meaning works best | Semantics stay correct and sentences stay readable |
The method doesn’t just generate a language—it filters out bad requirements by exposing combinations that defy intuitive understanding.
Implications — Why this matters beyond academia
For businesses building safety‑critical, regulated, or AI‑driven systems, this approach has uncomfortable but useful consequences:
- Requirements become testable artifacts, not prose suggestions.
- AI assistants shift roles—from creative writers to constrained semantic transformers.
- Governance improves by construction, not by compliance overlays.
This is particularly relevant as agentic systems, autonomous workflows, and AI‑mediated decision pipelines increasingly require auditable intent, not just executable code.
Conclusion — Language, finally under control
This paper is refreshingly unsentimental about natural language. It treats it not as a medium of expression, but as an interface—one that should be designed, constrained, and verified.
By anchoring language generation in formal semantics and using AI assistants as disciplined collaborators rather than free‑form authors, the authors demonstrate a scalable path toward requirements that are readable, verifiable, and precise.
Not poetic. Not flexible. But finally trustworthy.
Cognaptus: Automate the Present, Incubate the Future.