Controlled NL for Prompt (CNL-P)

• CNL-P is a controlled natural language designed for prompt specification, combining grammatical constraints with software engineering practices to reduce ambiguity.
• It employs a modular structure with defined fields like persona, constraints, inputs/outputs, and control flow, ensuring deterministic translation and consistency.
• Empirical studies demonstrate that CNL-P enhances code translation accuracy and prompt conversion, offering precise static analysis and compiler-like verification.

Controlled Natural Language for Prompt (CNL-P) is a structured, grammatically constrained natural language designed to serve as robust “APIs” for human–LLM interaction (Xing et al., 9 Aug 2025). In a narrower prompting pattern derived from code translation research, it is a structured NL scaffold embedded in prompts that enumerates program purpose, inputs/outputs, control flow, data structures, and key invariants, thus minimizing free-form prose that can mislead or overwhelm the model (Tai et al., 11 Jul 2025). More generally, it belongs to the broader family of controlled natural languages: constructed languages based on a certain natural language, being more restrictive concerning lexicon, syntax, and/or semantics while preserving most of their natural properties (Kuhn, 2015).

1. Foundations and intellectual lineage

Controlled natural languages were developed to improve communication among humans, to improve translation, or to provide natural and intuitive representations for formal notations (Kuhn, 2015). Within that tradition, machine-oriented CNLs are defined by well-defined semantics and deterministic translation into formal languages such as DRS, FOL, Prolog, KM, or ASP, which enables automated reasoning, consistency checking, question answering, and model building (Gao, 2019). CNL-P inherits that machine-oriented orientation, but directs it toward prompt specification, agent behavior, and LLM execution.

One formulation describes CNL-P as merging best practices from prompt engineering, such as persona setting, constraints, and chain-of-thought, with software engineering principles including modularity, abstraction, encapsulation, and separation of concerns (Xing et al., 9 Aug 2025). In that formulation, a prompt becomes an interface contract between a human “client” and an LLM “service,” with explicit modules for persona, responsibilities, constraints, inputs, outputs, and workflows (Xing et al., 9 Aug 2025). The same work classifies the language with Kuhn’s PENS scheme as $P^3 E^5 N^4 S^4$: reliably interpretable, maximally expressive, natural sentences, and a short but multi-page description (Xing et al., 9 Aug 2025).

This positioning is consistent with the broader survey literature on CNL. The PENS framework treats controlled languages as occupying a space between natural languages and formal languages, trading off precision, expressiveness, naturalness, and simplicity (Kuhn, 2015). CNL-P, as described in the recent software-engineering-oriented work, favors explicit structure and analyzability without abandoning natural-language surface form (Xing et al., 9 Aug 2025). In code translation research, the term is also used more specifically for a fixed-schema intermediate NL summary placed between source code and the requested target code, with the aim of reducing ambiguity and prompt variability (Tai et al., 11 Jul 2025).

2. Syntax, schema, and semantic discipline

A central feature of CNL-P is modular structure. One grammar defines the full prompt specification, CNLP_PROMPT, in terms of [PERSONA](https://www.emergentmind.com/topics/persona), CONSTRAINTS, DATA_TYPE, VARIABLES, WORKER, and API_SECTION, with subordinate constructs such as INPUTS, OUTPUTS, MAIN_FLOW, COMMAND, IF_BLOCK, and CALL (Xing et al., 9 Aug 2025). Typed variables must conform to declared schemas; IF_BLOCK conditions must evaluate to Boolean; and API calls must satisfy parameter and return-type specifications (Xing et al., 9 Aug 2025). This yields a prompt language in which typing, module boundaries, and execution flow are explicit rather than implied.

A second, domain-specific schema appears in code translation. There, CNL-P is proposed as a fixed-order block with fields Purpose, Inputs, Outputs, DataStructures, ControlFlow, PreConditions, PostConditions, and EdgeCases (Tai et al., 11 Jul 2025). The design also prescribes canonical names such as In1, In2, Out1 when source identifiers are ambiguous, a restricted control-flow vocabulary including Sequence, If(condition), Else, ElseIf(condition), For(init;cond;step), While(condition), and Return(value), and standardized pre/post-condition syntax such as Requires: and Ensures: (Tai et al., 11 Jul 2025).

The semantic motivation for such restrictions is longstanding in CNL research. Controlled vocabularies reduce polysemy, fixed sentence patterns limit attachment ambiguity and scope ambiguity, and deterministic interpretation rules make mappings to logic or executable representations predictable (Kuhn, 2015, Gao, 2019). In the prompt-specific setting, this same discipline is directed toward stable prompt execution. The software-engineering-oriented formulation treats data types, variables, constraints, and worker flows as first-class prompt elements (Xing et al., 9 Aug 2025), while the code-translation formulation treats structured NL as an authoritative specification for the target program (Tai et al., 11 Jul 2025).

Polysemy remains a serious issue even in controlled settings. One response is the use of micro-ontologies and multi-word units, where the same lexeme is partitioned across distinct OWL DL micro-domains and surfaced through sense-specific lexicalizations such as finance-bank versus river-bank (Gruzitis et al., 2015). Applied to CNL-P, this provides a mechanism for keeping prompt vocabulary both natural and semantically explicit: domain-scoped terms can remain readable while still mapping to unambiguous machine representations (Gruzitis et al., 2015).

3. Authoring environments, parsing, and validation

A recurring challenge in CNL is that such languages are easy to read but hard to write. Embedded controlled language research addresses this by treating the CNL as a proper fragment of a host language while allowing the parser to recognize the entire host language (Ranta, 2014). In that architecture, a single parser can accept in-fragment input, host-language input, and chunk-level input, and then distinguish them through tags such as UseCNL, UseHost, and UseChunks (Ranta, 2014). For prompt authoring, this supports graded feedback, rewrite suggestions, and progressive normalization from free NL to CNL-P rather than immediate rejection.

Predictive editing is another major design line. Codeco was introduced as a grammar notation specifically designed for CNLs and predictive editors, with special constructs for forward references, backward references, scope openers, and scope-closing rules [(Kuhn, 2011); (Kuhn, 2012)]. A large subset of ACE was represented in Codeco, and exhaustive generation on a core subset up to 10 tokens produced 2,250,869 distinct sentences with no duplicates, demonstrating syntactic unambiguity for that subset (Kuhn, 2011). The same body of work presents an extended chart parsing algorithm for complete and correct lookahead under anaphoric and scopal constraints, which is directly relevant to CNL-P editors that must propose only semantically resolvable continuations (Kuhn, 2012).

Recent CNL-P tooling extends these ideas from grammar to static analysis. An NL2CNL-P conversion tool uses transformer agents to extract persona, constraints, objectives, I/O, workflow steps, APIs, types, and variables from ordinary natural-language prompts, thereby lowering the learning curve for non-experts (Xing et al., 9 Aug 2025). A companion linting tool applies static analysis to CNL for the first time: Parser_Like tokenizes keyword_Like items and builds an AST_Like, while NodeVisitor_Like traverses the resulting JSON structure to perform variable collection, scope checks, type checks, constraint checks, and module-consistency checks (Xing et al., 9 Aug 2025).

The reported linting results are unusually strong. On 47 task instances across 14 error types, the linting tool achieved accuracy 100% and redundancy 0%, whereas a GPT-4o baseline achieved overall accuracy 76.60% and redundancy 19% (Xing et al., 9 Aug 2025). The reported error cases include exact location-and-reason mismatches and missed fine-grained constraint violations such as region='JP' not belonging to the allowed set {US, CA, AU, UK, IN} (Xing et al., 9 Aug 2025). This shifts prompt engineering from informal style guidance toward compiler-like pre-execution verification.

4. Formalization, reasoning, and controllability

CNL-P is closely tied to the problem of translating natural-language intent into formal or executable structure. A didactical proof-checking system for a controlled fragment of German mathematical discourse shows how such a language can be repurposed as a prompt format for LLM-based autoformalization (Carl, 2023). In that system, controlled sentences are mapped to either Diproche’s internal list format or to a schema [type,subtype,formalization], with sentence functions such as assumption, claim, variable declaration, and goal declaration explicitly marked (Carl, 2023). Reported results were 100% on 33 in-domain sentences with text-davinci-003 and 49/50 correct, or 98%, on a 50-sentence Boolean set theory set with GPT-4-Turbo assistant (Carl, 2023). The paper attributes much of that reliability to the CNL constraints themselves.

Reasoning extensions broaden the scope beyond monotonic formalization. One line of work argues that machine-oriented CNLs should support defaults, exceptions, and conversational implicatures, and formalizes these through Logic Programming with Defaults and Argumentation Theory (Gao, 2019). Another develops a paraconsistent route based on Annotated Predicate Calculus with consistency preferred stable models, so that inconsistent prompt or puzzle inputs do not collapse the whole representation (Gao et al., 2016). For CNL-P, these results make it possible to express not only tasks and schemas, but also non-monotonic policies such as defaults, cancellations, conflict constraints, and preference orderings over inconsistency (Gao, 2019, Gao et al., 2016).

Prompt control can also be continuous rather than purely symbolic. ControlPE distills the behavioral effect of a natural-language prompt into a LoRA adapter and then modulates its strength through a scalar merging weight $\alpha$ (Sun et al., 2023). In experiments on LLaMA2-7B-chat, the baseline without a CoT prompt on GSM8K achieved 12.6% accuracy, the explicit CoT prompt “Let’s think step by step” achieved 14.6%, and the distilled LoRA achieved 14.9%, with best performance around $\alpha \approx 0.8$ rather than at full strength (Sun et al., 2023). The same work reports approximately linear control of response length when only the down matrix is scaled, and a refusal-rate increase that is approximately linear for $\alpha \in [0.6, 1.0]` (Sun et al., 2023). This provides a distinct but compatible notion of CNL-P: controlled language directives can be turned into tunable, composable behavioral operators.

5. Empirical applications

The clearest recent application of CNL-P appears in code translation. The study “NL in the Middle: Code Translation with LLMs and Intermediate Representations” evaluates natural-language and AST-based intermediate representations under zero-shot, one-shot, two-step, and CoT prompting on CodeNet and AVATAR (Tai et al., 11 Jul 2025). For Open Gpt4 8X7B, CoT with an intermediate NL summary performed best: on CodeNet it achieved 42.4% success versus 28.6% for zero-shot, and on AVATAR it achieved 24.3% versus 17.6% for zero-shot (Tai et al., 11 Jul 2025). The paper reports that NL summaries were consistently more helpful than ASTs for Open Gpt4 8X7B, and that mixed IR orders mattered: NL followed by AST outperformed AST followed by NL (Tai et al., 11 Jul 2025). The proposed CNL-P extension of that work turns the intermediate summary into a compact schema with fixed fields, restricted vocabulary, and standardized pre/post-condition syntax (Tai et al., 11 Jul 2025).

The same software-engineering-oriented CNL-P paper evaluates whether general-purpose LLMs can execute such structured prompts without extra examples (Xing et al., 9 Aug 2025). Across six classification tasks from AllenAI Natural Instructions and five models—GPT-4o, Gemini-1.5-Pro-002, GPT-4o-Mini, Llama3-70B-8192, and Claude-3-Haiku—the reported finding is that LLMs understood CNL-P without special training or few-shot learning and achieved performance comparable to NL prompts (Xing et al., 9 Aug 2025). On prompt conversion quality, 93 prompts from “Awesome ChatGPT Prompts” were converted into CNL-P, RISEN, and RODES, and technical evaluators judged CNL-P more favorably on modularity, extensibility and maintainability, and process rigor (Xing et al., 9 Aug 2025).

A pre-LLM but structurally related application appears in conversational sensing. There, ITA Controlled English functioned as a common formal representation across humans and machine agents, with confirm, ask/tell, gist/expand, and why interactions progressively moving free NL reports into controlled statements (Preece et al., 2014). In a pilot experiment with 20 UK undergraduate students over 4 scenes and 10 minutes per scene, 137 scene descriptions were submitted, the average score was approximately 2.3 with median 2, and the SUS usability score mean was 64 with standard deviation approximately 13.1 (Preece et al., 2014). The system’s significance for CNL-P lies in its operational pattern: free NL input, controlled reformulation, formal reasoning, and back-conversion to concise human-facing feedback (Preece et al., 2014).

6. Limitations, trade-offs, and research directions

The main limitations are variability, domain dependence, and the persistent tension between naturalness and formal control. In code translation, gains were strongest for Open Gpt4 8X7B, modest for StarCoder, and negative for CodeGen under CoT-NL, indicating that benefits are model-specific and prompt-sensitive (Tai et al., 11 Jul 2025). In the software-engineering setting, non-technical evaluators rated CNL-P lower on readability because data types and variables required more time to process, although the authors argue that NL-to-CNL-P tooling can mitigate this (Xing et al., 9 Aug 2025). Earlier CNL survey work describes similar trade-offs at a higher level: increasing precision and simplicity generally constrains naturalness, while greater expressiveness tends to increase complexity (Kuhn, 2015).

Coverage and semantic robustness are likewise nontrivial. Embedded CNLs can gracefully parse out-of-fragment input, but host grammar coverage, chunking, morphological guessing, and coercions introduce their own failure modes (Ranta, 2014). Codeco’s predictive guarantees depend on deliberately restricted grammar design and do not cover every phenomenon of unrestricted natural language [(Kuhn, 2011); (Kuhn, 2012)]. Polysemy handling via micro-ontologies and multi-word units requires substantial ontology engineering, and paraconsistent reasoning frameworks demand explicit policies for priorities, cancellations, and completeness assumptions (Gruzitis et al., 2015, Gao et al., 2016).

Several forward paths are already identified in the literature. One proposal is a full CNL-P compiler that separates “what” from “how” and targets execution backends such as DSPy, LangChain, or Semantic Kernel (Xing et al., 9 Aug 2025). The same work proposes explicit GUARDRAIL constructs, executable requirements, ALTERNATIVE FLOWS, EXCEPTIONS, and SCENARIOS, together with documentation and testing agents (Xing et al., 9 Aug 2025). The code-translation line suggests automated generation and validation of CNL-P blocks from source ASTs, followed by consistency checks, unit tests, and repair prompts tied to exact schema fields (Tai et al., 11 Jul 2025). This suggests a broader convergence: CNL-P is increasingly treated not merely as a prompt style, but as a typed, lintable, and partially compilable specification layer for human–AI interaction.