Fact-checked by Grok 2 weeks ago

Attempto Controlled English

Attempto Controlled English (ACE) is a —a precisely defined of characterized by restricted syntax and semantics—designed to facilitate unambiguous knowledge representation and specification writing in a human-readable format. Developed as part of the Attempto project at the , ACE enables domain experts without formal logic training to author precise requirements and queries that can be automatically translated into formal representations such as . Its core objective is to bridge and computational processing by minimizing ambiguity while retaining the expressiveness of English, making it suitable for applications in , semantic technologies, and . Initiated in the mid-1990s by researchers including Norbert E. Fuchs, Uta Schwertel, and Rolf Schwitter, ACE evolved from efforts to create a for complex systems like automatic teller machines and library databases. The language's foundational grammar and mechanisms were detailed in early publications, with the Attempto Parsing Engine () introduced to provide deterministic translation of ACE texts into logical forms, including and Discourse Representation Structures. By 2013, ACE reached version 6.7, incorporating refinements for broader semantic coverage, and remains actively maintained with tools supporting its integration into modern reasoning systems. Ongoing developments, such as the 2021 extensions in the RACE reasoner, added support for mathematical operations (e.g., arithmetic and equations) and constructs, enhancing its utility for computational tasks. Key features of ACE include a vocabulary split between predefined function words (e.g., articles, conjunctions) and user-defined (e.g., domain-specific nouns and verbs), enforced construction rules to ensure unambiguity, and the generation of clarifying paraphrases during parsing. It supports declarative sentences, questions, and imperatives, with semantics aligned to monotonic to enable checking, entailment , and query answering via tools like . These attributes make ACE particularly valuable in fields requiring , such as and the , where it has been used to specify ontologies and generate executable specifications; recent applications include legal knowledge formalization and as of 2025.

Introduction

Definition and Purpose

Attempto Controlled English (ACE) is a , defined as a precisely specified subset of characterized by restricted and semantics to ensure unambiguity and facilitate machine processing. This restriction involves a limited and that eliminates common sources of found in full natural language, allowing for deterministic parsing and a single, clear interpretation of each text. Developed at the , ACE bridges the gap between human-readable expression and computational formalisms. The primary purposes of ACE include serving as a knowledge representation language to describe facts, rules, and relationships in a declarative manner; as a for defining and behaviors in domains like ; and as a for interrogating databases or ontologies through yes/no or wh-questions. These applications emphasize ACE's role in enabling non-experts to author precise content without needing expertise in formal logics, while ensuring the output is executable and verifiable by computers. For instance, ACE texts can be automatically translated into formal representations such as discourse representation structures (a variant of ), description logics, or subsets of OWL for semantic web applications. A key characteristic of ACE is its accessibility: it is readable and writable by English speakers without specialized training, yet it supports complex conceptual modeling through its structured yet natural phrasing. Consider the simple ACE sentence "A customer inserts a card," which represents a basic event in a knowledge base; this can be unambiguously mapped to a first-order logic formula like ∃x (customer(x) ∧ insert(x, card)), illustrating how ACE facilitates the transition from intuitive to precise formal systems for reasoning and inference.

History and Development

Attempto Controlled English (ACE) was initiated in 1995 at the as part of the Attempto project, led by Norbert E. Fuchs, with the goal of creating an unambiguous, English-based formalism for knowledge representation and specification. The project aimed to enable domain experts to interactively specify requirements using without requiring programming expertise, bridging the gap between natural language expressiveness and formal logic precision. In the late , early development focused on establishing ACE as a logic-based representation language, with foundational work published in 1996 that outlined its core principles for translating controlled English into . During the 2000s, ACE saw significant integration with standards, including translations to languages like RDF, , and SWRL, as explored in research from that decade to enhance interoperability and reasoning capabilities. Major version releases included ACE 6.6 prior to 2013, followed by version 6.7 in October 2013, which introduced extensions for queries and commands alongside updates to the Attempto Parsing Engine (APE) 6.7. Post-2013, no major version releases occurred, but the project has maintained active development through 2025, with improvements to the parsing engine and ongoing tool enhancements. Recent applications include legal knowledge formalization, as demonstrated in 2025 research using approaches to automate and verify legal texts in . ACE continues to influence active research in AI-centric language systems, supporting unified frameworks for knowledge authoring and reasoning.

Core Components

Vocabulary

Attempto Controlled English (ACE) employs a restricted vocabulary divided into three main categories to ensure precision and unambiguity in expression. Function words form a closed set of predefined elements, including determiners such as "every," "a," and "no"; connectives like "and," "or," and "if...then"; and prepositions such as "to," "in," and "of." These words handle structural roles and are fixed to avoid variation. Content words, on the other hand, are domain-specific and user-defined, encompassing nouns, verbs, adjectives, and adverbs that must be explicitly declared in a lexicon before use. Fixed phrases include specialized constructions like the negation phrase "it is false that" for sentence-level negation, which extends its scope to the entire following clause. Restrictions on the are stringent to eliminate and . Synonyms and abbreviations are prohibited, requiring strict in — for instance, if "" is defined, "client" cannot be used interchangeably unless explicitly equated in the . Verbs are limited to the tense in third-person singular or forms, , and indicative , excluding modals, past or future tenses; passive constructions are supported using auxiliary "is" + past participle. The can be extended through a domain-specific , allowing addition of new without modifying the core function words or grammar, thus maintaining the language's formal properties across applications. Examples illustrate these categories in practice. Nouns are classified as common (e.g., "," "") or proper (e.g., "," "VisaCard"), with support for both singular and plural forms (e.g., "customers"). Verbs distinguish transitive (e.g., "inserts," "enters") from intransitive types, with prepositional phrases like "give to" treated as units. Quantifiers include universal forms like "every" and "no," existential "there is a," and numerical variants such as "at least N" (e.g., "at least three customers") or "exactly N" (interpreted as "at least N and at most N"). These vocabulary choices reduce by enforcing unambiguous meanings that directly map to logical forms, such as predicates, thereby facilitating automated processing and reasoning without loss of intent.

Grammar Rules

Attempto Controlled English (ACE) enforces a strict syntactic to ensure unambiguous and , with sentences adhering to a subject-verb-complement-adjunct order. This basic structure limits complexity through rules for constructions like relative clauses and passive forms, with fixed attachments for prepositional phrases (except "of") to verbs or nouns, thereby reducing . For instance, complements directly follow the verb, and adjuncts (adverbs or prepositional phrases) appear either before or after the , maintaining a predictable linear progression. Key rules govern the formation of valid ACE texts, requiring terms to be declared explicitly upon first use through noun phrases or appositions, such as introducing variables with "A man X sleeps." Modifiers are restricted, with adjectives positioned before nouns (e.g., "a valid ") and prepositional phrases attaching to verbs rather than nouns to avoid attachment ambiguities. ACE supports coordination using "and" or "or" for phrases or sentences of the same type (e.g., "A inserts a and enters a "), which is right-associative, and subordination via conditionals like "" (e.g., "If a is valid then a inserts it"). These rules draw from defined vocabulary categories, such as nouns, verbs, and adjectives, to form syntactically correct units. Tense and aspect in ACE are limited primarily to the simple present for declarative and interrogative sentences, with no support for past or future tenses in finite verbs, and progressive or perfect forms constrained to exclusion to preserve simplicity. Imperatives in commands may omit tense markers, but overall, this restriction ensures temporal neutrality in specifications. At the text level, ACE consists of sequences of sentences, queries (yes/no or wh-questions ending in "?"), or commands (ending in "!"), with no general imperatives allowed beyond commands; sentences imply sequential order without explicit conjunctions. These grammar rules differentiate ACE from standard English by resolving common ambiguities through fixed rules for prepositional phrase attachments and structured passives and relative clauses, enforcing deterministic syntax for computational processing. This controlled approach prioritizes clarity over expressive freedom, aligning with ACE's purpose in knowledge representation. Components have evolved since early versions; current ACE (version 6.7, as of 2025) includes features like plural nouns and passive constructions.

Text Structures

Basic Sentences

Basic sentences in Attempto Controlled English (ACE) form the foundational units of the language, consisting of simple declarative statements that assert facts without embedding clauses or interrogative elements. These sentences follow a strict syntactic : a (typically a ) followed by a , optional complements (such as direct objects or prepositional phrases), and optional adjuncts (like adverbs or prepositional phrases indicating time, place, or manner). This ensures unambiguity and direct mappability to logical forms, making ACE suitable for knowledge representation. The subject must be a quantified (e.g., using "every," "each," "no," or "some") or a definite (e.g., with "the" or proper names), prohibiting bare plurals without determiners to avoid existential . Verbs are limited to , third-person forms of full s (intransitive, transitive, or ditransitive) or the "be," with no support for or tense variations; while core ACE (version 3.0) excludes modals, later versions (from around 2008) introduced limited support for "may" (admissibility) and "should" (recommendation). Complements, when required by the verb, are phrases or prepositional phrases, while provide additional, non-essential and can appear at the end of the sentence. Representative examples illustrate this structure and its logical implications. For universal quantification, "Every man loves a woman" translates to a logical statement where for all men, there exists a woman who is loved by that man. For existential quantification, "Some dogs bark" asserts that there are dogs that bark, without specifying universality. Another example is "John enters a card," where "John" is a proper noun subject, "enters" is a transitive verb, and "a card" is the direct object complement. In ACE texts, basic sentences serve as the core building blocks for constructing knowledge bases, each asserting a precise fact that can be parsed into first-order logic predicates for reasoning and querying. This simplicity allows ACE to maintain readability while ensuring computational tractability, drawing from a predefined vocabulary of nouns and verbs to populate subjects and predicates.

Complex Constructions and Queries

Attempto Controlled English (ACE) extends basic declarative sentences through composite structures that allow for more expressive and logically precise representations. Composite sentences are formed by combining simpler elements using coordination, subordination, and relative clauses, enabling the construction of hierarchical and interconnected statements while maintaining syntactic restrictions to ensure unambiguity. These constructions build recursively on core sentence patterns, such as subject-verb-object, to represent relationships like alternatives, conditions, and modifications without introducing ambiguity. Later versions of ACE (post-version 3.0) added support for modal verbs "may" and "should" in complex constructions to express admissibility and recommendation. Coordination in ACE links elements of the same using "and" for or "or" for disjunction, applying across sentences, noun phrases, or s. For instance, "Every has inhabitants and is inhabited" coordinates a with an , distributing the verb implicitly to maintain parallelism. Disjunctions, such as "Every has inhabitants or is empty," express inclusive alternatives, with "or" weaker than "and" unless commas intervene to adjust precedence. These forms adhere to a where precedes , which precedes disjunction, ensuring predictable scoping. Subordination introduces dependency through conditional clauses or relative modifiers. Conditional statements follow the pattern "If [condition], then [consequence]," as in "If a customer inserts a valid card, then the machine accepts it," where the condition's elements remain accessible in the consequence for anaphora. Relative clauses modify nouns using "who," "which," or "that," with right-associating attachment to the nearest preceding noun, exemplified by "the man who runs" in "The man who runs sees the dog that barks." This structure allows embedding of quantified or negated elements, such as "a dog that does not bark," to refine descriptions precisely. Negation in ACE is explicit and scoped to avoid double negations, using "no" for noun phrases (equivalent to "there is no"), "does not" or "is not" for verb phrases, or "it is false that" for entire sentences. For example, "No city is empty" negates existence, while "It is false that every city has inhabitants" scopes over the quantified statement. Distribution over coordination applies, as in "A customer does not insert a card or a code," interpreted as neither action occurring. These mechanisms prevent unintended positive implications from multiple negations, aligning with ACE's commitment to monotonic logic. Queries in ACE transform declarative forms into interrogative ones, supporting yes/no questions via subject-auxiliary inversion, such as "Does every man run?" for confirmation, or wh-questions using interrogatives like "which," "who," or "what" to target specific components: "Which man runs?" These retain ACE's quantifiers and modifiers, as in "Show me all dogs that bark," a wh-query with a eliciting a list. Directives are expressed using declarative syntax to preserve formal translation.

Ambiguity Resolution

Avoidance Techniques

Attempto Controlled English (ACE) employs lexical restrictions to minimize ambiguity by limiting the vocabulary to precisely defined terms, where users specify content words such as nouns, verbs, adjectives, and adverbs, while function words like determiners, prepositions, and pronouns are predefined and fixed in meaning. Polysemous words are effectively banned through this user-defined semantics, ensuring each term has a single, unambiguous interpretation within the lexicon; for instance, words like "bank" are avoided unless explicitly defined to eliminate multiple senses. Prepositions have restricted, fixed meanings—for example, "in" is used for location, containment, or time periods, preventing metaphorical or other ambiguities. Syntactically, ACE restricts constructions prone to multiple attachments or interpretations. While early versions prohibited passive voice, current ACE supports it using past participles with optional "by" phrases for agents (e.g., "A card is inserted by a customer"), ensuring clear relations through attachment rules. Adverbial phrases that could attach ambiguously to verbs, nouns, or other elements are governed by placement rules, with adverbs permitted in sentence-initial positions but attached to the following verb phrase (e.g., "Carefully, a customer enters a credit card"). Mandatory determiners, such as "a," "the," or "every," are required for all noun phrases to eliminate indefinite or bare noun ambiguities, ensuring explicit quantification from the outset. Semantic constraints in ACE fix quantification scope strictly by word order, where the surface textual position determines the scope, preventing the classic ambiguity in sentences like "Flying planes can be dangerous," which is prohibited; instead, explicit relative clauses are mandated, such as "Planes that fly can be dangerous" or "The flying of planes can be dangerous," to clarify whether planes or the act of flying is the subject. Implicit arguments are disallowed, requiring all participants in events to be explicitly stated, which avoids underspecification in verb phrases. For plurals, which inherently risk collective-distributive ambiguities, ACE supports plural noun phrases and uses markers like "each" for distributive readings or "as a whole" for collective ones; for example, "Three men lift a table" defaults to a collective interpretation but can be precisified as "Three men each lift a table" to enforce distributivity without altering core syntax. These techniques collectively ensure that ACE texts are parsed deterministically into a single logical form, prioritizing prevention over post-hoc resolution.

Interpretation Rules

Attempto Controlled English (ACE) employs deterministic interpretation rules to assign a unique meaning to each syntactically valid sentence, resolving potential ambiguities that might arise in unrestricted English. These rules ensure that every ACE text translates into exactly one discourse representation structure (DRS), facilitating unambiguous processing and logical translation. By prioritizing specific scoping, attachment, and reference conventions, ACE avoids the need for multiple possible interpretations, distinguishing it from full natural language where context-dependent ambiguities are common. Scope resolution in ACE follows a left-to-right, widest-scope for quantifiers, where local quantifiers such as every () and a (existential) extend their scope to the end of the or coordinated unless subordinated. For instance, "Every man loves a woman" is interpreted with the universal quantifier taking scope over the existential, yielding ∀x (man(x) → ∃y (woman(y) ∧ loves(x,y))). Conversely, "A man visits every city" assigns existential scope over universal, resulting in ∃x (man(x) ∧ ∀y (city(y) → visits(x,y))). This fixed ordering prevents scope ambiguity, ensuring predictable without requiring additional disambiguation steps. Attachment rules dictate how modifiers connect to sentence elements, with prepositional phrases attaching to the nearest rather than the preceding to maintain clarity. In the "A enters a with a ," the phrase "with a " modifies the "enters," implying the code accompanies the entry action, not that the inherently possesses the code. Adverbs follow a similar , attaching to the immediately preceding in cases of potential , as in "A who enters a manually types a ," where "manually" qualifies "enters." These conventions eliminate structural ambiguities that could alter meaning in broader English usage. Definite descriptions in ACE are interpreted based on context availability, referring uniquely to the most recent, gender- and number-matching antecedent if accessible, or existentially introducing a new entity otherwise. For example, "John goes to the bank" introduces a new, existentially quantified , while in a sequence like "There is a red ball. sees the ball," "the ball" uniquely refers to the previously mentioned red ball. This rule supports existential uniqueness when no prior exists, ensuring definites contribute to a coherent without unresolved references. Negation scope in ACE extends to the end of the subordinated introduced by "that," binding tightly to avoid wide ambiguities. The "It is false that a man waits and a dog barks" requires coordination with repeated "that" clauses—"It is false that a man waits and that a dog barks"—to negate both conjuncts fully; otherwise, applies only to the first. This scoped integrates seamlessly with quantifier rules, preserving the overall unique . Collectively, these rules—spanning , attachment, definites, and —guarantee that any valid text yields a single, well-defined , enabling direct mapping to formal logics while minimizing reliance on external avoidance techniques for ambiguity prevention.

Advanced Elements

Anaphoric References

Attempto Controlled English () supports anaphoric references to enable coherent across multiple sentences, allowing writers to refer back to previously introduced entities without repetition, while ensuring unambiguous logical . These references primarily include definite noun phrases (such as "the man"), personal pronouns (like "he," "it," or "they"), and variables (e.g., "X" or dynamic names like "A1"). Variables are introduced in to indefinite phrases and can be reused as bare references or within definite phrases, facilitating precise tracking of entities in complex texts. Resolution of anaphors follows strict rules emphasizing , recency, specificity, and reflexivity to guarantee a unique antecedent in the . An antecedent must be an accessible from prior sentences, excluding those embedded in negations, modals, subordinations, interrogatives, commands, or the antecedents of universal quantifiers and conditionals (except in the consequent of if-then statements); proper names remain universally accessible. Non-reflexive pronouns resolve to the most recent accessible antecedent agreeing in and number, excluding the sentence's own subject, while reflexive pronouns (e.g., "herself") bind to the current sentence's subject. Definite s target the most recent and specific matching antecedent, and variables link directly to their introduced . No cataphora—forward references—is permitted, ensuring all anaphors point backward. Constraints further enforce precision: anaphors must agree in number and with their antecedents, and , expressions, lists, sets, or strings cannot serve as antecedents. Bridging inferences via definites are limited; if no explicit antecedent exists, a definite may introduce a new under Russell's presupposition, but ACE prioritizes explicit prior mentions for . For example, in the "A enters a . It is valid," the "it" resolves to "a " due to recency and agreement. Similarly, " has a ball X. He throws the ball X," uses a for explicit linking. These mechanisms play a key role in producing compact, readable texts that translate reliably to without ambiguity.

Logical Mappings

Attempto Controlled English (ACE) constructs are systematically translated into formal logical representations to enable computational processing and reasoning. The primary translation targets include first-order logic (FOL) via discourse representation structures (DRS), the Web Ontology Language (OWL) for ontologies, and the Semantic Web Rule Language (SWRL) for rules. These mappings leverage DRS as an intermediate representation, which captures the semantics of ACE texts in a structured, logic-based format that can be further transformed into the target logics. The translation process is handled by the Attempto Parsing Engine (APE), which parses ACE texts into DRS and generates corresponding logical forms, including handling anaphora across discourse through resolution rules that link pronouns and definite descriptions to antecedents. Key mappings transform basic ACE elements into logical components: sentences map to predicates, such as "A man loves a woman" becoming ∃x ∃y (man(x) ∧ woman(y) ∧ loves(x, y)); quantifiers are rendered as universal (∀) or existential (∃) operators, with "every" denoting implication (e.g., "Every man runs" translates to ∀x (man(x) → runs(x))); and negation is expressed as ¬, as in "No man runs" mapping to ¬∃x (man(x) ∧ runs(x)). For queries, ACE interrogatives are converted to SQL-like queries or (DL) queries compatible with reasoners, facilitating database retrieval or ontological inference. These logical mappings provide significant benefits by enabling , theorem proving over texts, and interoperability with tools, allowing non-experts to author and verify knowledge in a readable format while integrating with formal systems.

Tools and Applications

Parsing and Processing Tools

The Attempto Parsing Engine () serves as the primary tool for processing Attempto Controlled English (), functioning as a robust parser that translates texts into unambiguous logical representations. Implemented using a augmented with feature structures in , generates discourse representation structures () as its core output, which can then be further translated into (), , or formats to facilitate reasoning and interoperability. It also provides detailed feedback on invalid inputs, including error diagnosis to guide users toward compliant syntax, and supports of the resulting logical forms for verification. Additionally, enables of multiple texts, making it suitable for large-scale tasks. Released in version 6.7 in 2013, APE remains actively maintained as under the GNU Lesser General Public License, with updates available as of 2025. methodologies have applied for formalizing legal texts, demonstrating its utility in domain-specific contexts. Similarly, the project has explored for representing medical guidelines using the Guideline Elements Model (). Complementing APE, the Attempto Reasoner (RACE) performs automated inference on parsed ACE texts, supporting tasks such as consistency checking, theorem proving, and query answering by translating DRS into resolvable logical forms. In 2021, RACE was extended to support mathematical operations (e.g., arithmetic and equations) and constructs. For interactive authoring, the ACE Editor assists users in constructing valid texts by offering real-time syntax guidance and suggestions, reducing the learning curve without requiring deep linguistic expertise. These tools integrate seamlessly with technologies, enabling ACE texts to be mapped onto ontologies like DOLCE for enhanced in distributed systems.

Practical Use Cases

Attempto Controlled English (ACE) has been applied in , where domain experts formulate precise descriptions of system behaviors that can be automatically translated into formal representations for and prototyping. For instance, specifications for an , such as "The customer enters a and a numeric personal code. If it is not valid then SM rejects the ," are written in ACE and parsed into representation structures or code, enabling simulation and validation without requiring programming expertise. This approach bridges the communication gap between non-technical stakeholders and developers by maintaining readability while ensuring unambiguity. In ontologies and the , ACE facilitates the construction of knowledge bases by allowing users to define concepts and relations in a controlled subset of English, which is then mapped to formal languages like DL. A notable example is its use in bioinformatics for expressing protein interaction ontologies, where statements like those describing molecular interactions are verbalized and queried to support . Similarly, in legal domains, ACE has been employed to build ontologies from regulatory texts, enabling over compliance rules. Tools like the Attempto Parsing Engine (APE) briefly support these mappings by generating from ACE inputs. ACE supports natural language interfaces for querying databases and AI planning systems, where users pose questions or define plans in controlled English that are translated to first-order logic for execution. For example, ontology querying allows end-users to retrieve information using ACE sentences like "Which proteins interact with protein X?" which are processed via SPARQL after formalization. In planning contexts, ACE specifications of constraints and goals, such as those in process handbooks, enable simulation of workflows. Recent applications in 2025 include legal knowledge formalization using a methodology to translate normative legal texts into for computational processing. In medical documentation, has been used to encode guidelines, such as those for urinary tract infections in febrile infants and young children—for example, "If the patient is a young child who has an unexplained fever and the patient is sufficiently-ill then the should analyze a culture of a urine-specimen"—with plans for integration into electronic health records for patient-specific decision support. These use cases highlight ACE's advantages in reducing miscommunication between experts and machines, as its controlled syntax minimizes while allowing non-experts to engage in formal tasks like and querying. However, ACE requires a predefined domain to ensure coverage, and it is unsuitable for full texts due to its restrictive .

References

  1. [1]
    Attempto Controlled English
    Attempto Controlled English (ACE) is a controlled natural language, i.e. a rich subset of standard English designed to serve as knowledge representation ...
  2. [2]
    [cmp-lg/9603003] Attempto Controlled English (ACE) - arXiv
    Mar 13, 1996 · Abstract: Attempto Controlled English (ACE) allows domain specialists to interactively formulate requirements specifications in domain ...
  3. [3]
    Reasoning in Attempto Controlled English: Mathematical and ...
    2021. Reasoning in Attempto Controlled English: Mathematical and Functional Extensions. In Proceedings of the Seventh International Workshop on Controlled ...Missing: developments | Show results with:developments
  4. [4]
    [PDF] Attempto Controlled English (ACE)
    Attempto Controlled English (ACE) is a language specifically designed to write specifications. ACE is a controlled natural language (cf.
  5. [5]
    Attempto Controlled English - Wikipedia
    Attempto Controlled English (ACE) is a controlled natural language, ie a subset of standard English with a restricted syntax and restricted semantics.Overview · Grammar · Constraining ambiguity
  6. [6]
    Attempto Controlled English for Knowledge Representation
    Attempto Controlled English (ACE) is a controlled natural language, ie a precisely defined subset of English that can automatically and unambiguously be ...
  7. [7]
    [PDF] Bidirectional mapping between OWL DL and Attempto Controlled ...
    We describe ongoing work on a bidirectional mapping be- tween Attempto Controlled English (ACE) and OWL DL. ACE is a well-studied controlled natural language, ...
  8. [8]
    [PDF] Attempto Controlled English
    • Attempto Controlled English combines pros of formal and natural languages. Page 4. Stanford 2005. 4. Attempto Controlled English (ACE). • ACE is a controlled ...
  9. [9]
    Attempto Project
    No readable text found in the HTML.<|control11|><|separator|>
  10. [10]
    Attempto Controlled English as a Semantic Web Language
    In this thesis, we are only interested in the latter type of controlled natural languages. In the following sections we introduce Attempto Controlled English ( ...<|control11|><|separator|>
  11. [11]
    Attempto News
    We are releasing a slightly extended version 6.7 of Attempto Controlled English (ACE) and an improved version 6.7 of the Attempto Parsing Engine (APE).
  12. [12]
    [PDF] Attempto Controlled English for Knowledge Representation
    Attempto Controlled English (ACE). • Attempto Controlled English combines pros of formal and natural languages. • ACE is a controlled natural language.
  13. [13]
    [PDF] First-Order Reasoning for Attempto Controlled English
    Abstract. RACE is a first-order reasoner for Attempto Controlled English. (ACE) that can show the (in-) consistency of a set of ACE axioms, prove ACE.
  14. [14]
    ACE 6.7 Construction Rules
    ### Summary of ACE 6.7 Construction Rules
  15. [15]
    [PDF] An Abstract Grammar for ACE 4.0 1 Introduction
    Attempto Controlled English (ACE) is a controlled natural language specifically designed for requirements specifications and knowledge representation. ACE is a ...
  16. [16]
    ACE 6.7 Syntax Report
    ### Summary of ACE Syntax (Attempto Controlled English 6.7)
  17. [17]
    ACE 6.7 in a Nutshell - Attempto Controlled English
    The grammar of ACE defines the syntax of ACE texts. ACE's syntax is expressed as a set of construction rules (cf. ACE Construction Rules). The meaning of ...
  18. [18]
    (PDF) Attempto Controlled English for Knowledge Representation
    Aug 7, 2025 · Attempto Controlled English for Knowledge Representation ... It is false that a customer inserts a card. It is not provable that ...
  19. [19]
    Attempto Controlled English as a Semantic Web Language
    PDF | On Nov 26, 2007, Kaarel Kaljurand published Attempto Controlled English as a Semantic Web Language | Find, read and cite all the research you need on ...
  20. [20]
    [PDF] Controlling Plural Ambiguities in Attempto Controlled English (ACE)
    The best solution to the problem of plural ambiguity is of course to avoid plurals wherever possi- ble and use singular sentences instead. Unfortunately ...
  21. [21]
    ACE 6.7 Interpretation Rules - Attempto Controlled English
    ACE 6.7 Interpretation Rules. Each ACE sentence has only one meaning. However, if interpreted in full English, an ACE sentence can have many meanings.
  22. [22]
    (PDF) Attempto Controlled English (ACE) - ResearchGate
    Attempto Controlled English (ACE) allows domain specialists to interactively formulate requirements specifications in domain concepts.
  23. [23]
    [PDF] Bidirectional mapping between OWL DL and Attempto Controlled ...
    We describe ongoing work on a bidirectional mapping be- tween Attempto Controlled English (ACE) and OWL DL. ACE is a well-studied controlled language, with a ...
  24. [24]
    [PDF] Attempto controlled English for knowledge representation - ZORA
    Fuchs, N E; Kaljurand, K; Kuhn, T (2008). Attempto controlled English for knowledge representation. In: 4th International Summer School 2008, Venice, Italy ...
  25. [25]
    [PDF] Reasoning in Attempto Controlled English
    Attempto Controlled English (ACE) – a subset of English that can be unambiguously translated into first-order logic – is a knowl- edge representation language.
  26. [26]
    Attempto/APE: Parser for Attempto Controlled English (ACE) - GitHub
    This document explains how APE (ACE Parsing Engine) is compiled and used. In order to compile and run APE, you first need to install a recent version of SWI- ...<|control11|><|separator|>
  27. [27]
    Attempto Tools and Resources
    Apr 4, 2025 · ACE (Attempto Controlled English). ACE in a Nutshell is a short overview of the ACE language; ACE Construction Rules lists the rules that ...
  28. [28]
    Attempto Downloads
    The source code of the Attempto Parsing Engine (APE) plus some related tools is available under the GNU Lesser General Public License, on GitHub: project page ...Missing: Controlled English
  29. [29]
    [PDF] Legal Knowledge Formalization in Attempto Controlled English | HAL
    Apr 4, 2025 · Indeed, the Attempto Parsing Engine (APE) [14] generates a semantic representation of sentences in the form of Discourse Repre- sentation ...
  30. [30]
    ERGO - Welcome - Guideline Elements Model (GEM)
    Apply Attempto Controlled English (ACE) to improve the authoring and the implementation of guideline recommendations;; Develop and evaluate a controlled ...
  31. [31]
    First-Order Reasoning for Attempto Controlled English - SpringerLink
    RACE is a first-order reasoner for Attempto Controlled English (ACE) that can show the (in-) consistency of a set of ACE axioms, prove ACE theorems from ACE ...
  32. [32]
    [PDF] Attempto Controlled English (ACE) for Software Specifications
    Attempto Controlled English (ACE) has three components. • a vocabulary with predefined function words (e.g. she, the, and, if, not) and application-specific ...
  33. [33]
    [PDF] Attempto Controlled English Meets the Challenges of Knowledge ...
    a user- friendly first-order logic language with a rich English syntax — and its associated tools, and demonstrate how.Missing: 1995 | Show results with:1995
  34. [34]
    Querying ontologies: a controlled english interface for end-users
    We address this problem by presenting a natural language interface to semantic web querying. The interface allows formulating queries in Attempto Controlled ...
  35. [35]
    [PDF] Controlled Natural Language for Clinical Practice Guidelines*
    In order to address this problem, we investigate writing guidelines in At- tempto Controlled English (ACE) [3]. ACE is a controlled natural language, i.e.. * ...