Showing papers on "Formal grammar published in 2011"

ChemicalTagger: A tool for semantic text-mining in chemistry

Abstract: The primary method for scientific communication is in the form of published scientific articles and theses which use natural language combined with domain-specific terminology. As such, they contain free owing unstructured text. Given the usefulness of data extraction from unstructured literature, we aim to show how this can be achieved for the discipline of chemistry. The highly formulaic style of writing most chemists adopt make their contributions well suited to high-throughput Natural Language Processing (NLP) approaches. We have developed the ChemicalTagger parser as a medium-depth, phrase-based semantic NLP tool for the language of chemical experiments. Tagging is based on a modular architecture and uses a combination of OSCAR, domain-specific regex and English taggers to identify parts-of-speech. The ANTLR grammar is used to structure this into tree-based phrases. Using a metric that allows for overlapping annotations, we achieved machine-annotator agreements of 88.9% for phrase recognition and 91.9% for phrase-type identification (Action names). It is possible parse to chemical experimental text using rule-based techniques in conjunction with a formal grammar parser. ChemicalTagger has been deployed for over 10,000 patents and has identified solvents from their linguistic context with >99.5% precision.

A Systematic Approach to Model Checking Human–Automation Interaction Using Task Analytic Models

Abstract: Formal methods are typically used in the analysis of complex system components that can be described as “automated” (digital circuits, devices, protocols, and software). Human-automation interaction has been linked to system failure, where problems stem from human operators interacting with an automated system via its controls and information displays. As part of the process of designing and analyzing human-automation interaction, human factors engineers use task analytic models to capture the descriptive and normative human operator behavior. In order to support the integration of task analyses into the formal verification of larger system models, we have developed the enhanced operator function model (EOFM) as an Extensible Markup Language-based, platform- and analysis-independent language for describing task analytic models. We present the formal syntax and semantics of the EOFM and an automated process for translating an instantiated EOFM into the model checking language Symbolic Analysis Laboratory. We present an evaluation of the scalability of the translation algorithm. We then present an automobile cruise control example to illustrate how an instantiated EOFM can be integrated into a larger system model that includes environmental features and the human operator's mission. The system model is verified using model checking in order to analyze a potentially hazardous situation related to the human-automation interaction.

Foundations of Nominal Techniques: Logic and Semantics of Variables in Abstract Syntax

Abstract: We are used to the idea that computers operate on numbers, yet another kind of data is equally important: the syntax of formal languages, with variables, binding, and alpha-equivalence. The original application of nominal techniques, and the one with greatest prominence in this paper, is to reasoning on formal syntax with variables and binding. Variables can be modelled in many ways: for instance as numbers (since we usually take countably many of them); as links (since they may `point' to a binding site in the term, where they are bound); or as functions (since they often, though not always, represent `an unknown'). None of these models is perfect. In every case for the models above, problems arise when trying to use them as a basis for a fully formal mechanical treatment of formal language. The problems are practical—but their underlying cause may be mathematical. The issue is not whether formal syntax exists, since clearly it does, so much as what kind of mathematical structure it is. To illustrate this point by a parody, logical derivations can be modelled using a Godel encoding (i.e., injected into the natural numbers). It would be false to conclude from this that proof-theory is a branch of number theory and can be understood in terms of, say, Peano's axioms. Similarly, as it turns out, it is false to conclude from the fact that variables can be encoded e.g., as numbers, that the theory of syntax-with-binding can be understood in terms of the theory of syntax-without-binding, plus the theory of numbers (or, taking this to a logical extreme, purely in terms of the theory of numbers). It cannot; something else is going on. What that something else is, has not yet been fully understood. In nominal techniques, variables are an instance of names, and names are data. We model names using urelemente with properties that, pleasingly enough, turn out to have been investigated by Fraenkel and Mostowski in the first half of the 20th century for a completely different purpose than modelling formal language. What makes this model really interesting is that it gives names distinctive properties which can be related to useful logic and programming principles for formal syntax. Since the initial publications, advances in the mathematics and presentation have been introduced piecemeal in the literature. This paper provides in a single accessible document an updated development of the foundations of nominal techniques. This gives the reader easy access to updated results and new proofs which they would otherwise have to search across two or more papers to find, and full proofs that in other publications may have been elided. We also include some new material not appearing elsewhere.

Programming services with correlation sets

Abstract: Correlation sets define a powerful mechanism for routing incoming communications to the correct running session within a server, by inspecting the content of the received messages. We present a language for programming services based on correlation sets taking into account key aspects of service-oriented systems, such as distribution, loose coupling, open-endedness and integration. Distinguishing features of our approach are the notion of correlation aliases and an asynchronous communication model. Our language is equipped with formal syntax, semantics, and a typing system for ensuring desirable properties of programs with respect to correlation sets. We provide an implementation as an extension of the JOLIE language and apply it to a nontrivial real-world example of a fully-functional distributed user authentication system.

Monitoring of Probabilistic Timed Property Sequence Charts

Abstract: Run-time monitoring is an important technique to detect erroneous run-time behaviors. Several techniques have been proposed to automatically generate monitors from specification languages to check temporal and real-time properties. However, monitoring of probabilistic properties still requires manual generation. To overcome this problem, we define a formal property specification language called Probabilistic Timed Property Sequence Chart (PTPSC). PTPSC is a probabilistic and timed extension of the existing scenario-based specification formalism Property Sequence Chart (PSC). We have defined a formal grammar-based syntax and have implemented a syntax-directed translator that can automatically generate a probabilistic monitor which combines timed B”uchi automata and a sequential statistical hypothesis test process. We validate the generated monitors with a set of experiments performed with our tool WS-PSC Monitor. Copyright © 2011 John Wiley & Sons, Ltd.

Verifying functional behaviors of automotive products in EAST-ADL2 using UPPAAL-PORT

Abstract: We study the use of formal modeling and verification techniques at an early stage in the development of safety-critical automotive products which are originally described in the domain specific architectural language EAST-ADL2. This architectural language only focuses on the structural definition of functional blocks. However, the behavior inside each functional block is not specified and that limits formal modeling and analysis of systems behaviors as well as efficient verification of safety properties. In this paper, we tackle this problem by proposing one modeling approach, which formally captures the behavioral execution inside each functional block and their interactions, and helps to improve the formal modeling and verification capability of EAST-ADL2: the behavior of each elementary function of EAST-ADL2 is specified in UPPAAL Timed Automata. The formal syntax and semantics are defined in order to specify the behavior model inside EAST-ADL2 and their interactions. A composition of the functional behaviors is considered a network of Timed Automata that enables us to verify behaviors of the entire system using the UPPAAL model checker. The method has been demonstrated by verifying the safety of the Brake-by-wire system design.

The Motion Grammar for physical human-robot games

Abstract: We introduce the Motion Grammar, a powerful new representation for robot decision making, and validate its properties through the successful implementation of a physical human-robot game. The Motion Grammar is a formal tool for task decomposition and hybrid control in the presence of significant online uncertainty. In this paper, we describe the Motion Grammar, introduce some of the formal guarantees it can provide, and represent the entire game of human-robot chess through a single formal language. This language includes game-play, safe handling of human motion, uncertainty in piece positions, misplaced and collapsed pieces. We demonstrate the simple and effective language formulation through experiments on a 14-DOF manipulator interacting with 32 objects (chess pieces) and an unpredictable human adversary.

Can mathematics explain the evolution of human language

Abstract: Investigation into the sequence structure of the genetic code by means of an informatic approach is a real success story. The features of human language are also the object of investigation within the realm of formal language theories. They focus on the common rules of a universal grammar that lies behind all languages and determine generation of syntactic structures. This universal grammar is a depiction of material reality, i.e. the hidden logical order of things and its relations determined by natural laws. Therefore mathematics is viewed not only as an appropriate tool to investigate human language and genetic code structures through computer science-based formal language theory but is itself a depiction of material reality. This confusion between language as a scientific tool to describe observations/experiences within cognitive constructed models and formal language as a direct depiction of material reality occurs not only in current approaches but was the central focus of the philosophy of science ...

An Invariant Preserving Transformation for PLC Models

Abstract: Many applications in the industrial control domain are safety-critical. A large number of analysis techniques to guarantee safety may be applied at different levels in the development process of a Programmable Logic Controller. The development process is typically associated with a tool chain comprising model transformations. The preservation of safety properties in model transformations is necessary to achieve a safe system. Preservation can be guaranteed by showing that invariants are preserved by transformations. Adequate transformation rules and invariant specification mechanisms are needed for this. We report on a transformation from Sequential Function Charts and Function Block Diagrams of the IEC 61131 -- 3 standard to BIP. Our presentation features a description of formal syntax and semantics of the involved languages. We present transformation rules for generating BIP code out of IEC 61131 -- 3 specifications. Based on this, we establish a notion of invariant preservation between the two languages.

Grammar-based genetic programming

Abstract: Tree-based genetic programming (GP) has several known shortcomings: difficult adaptability to specific programming languages and environments, the problem of closure and multiple types, and the problem of declarative representation of knowledge. Most of the methods that try to solve these problems are based on formal grammars. The precise effect of their distinctive features is often difficult to analyse and a good comparison of performance in specific problems is missing. This thesis reviews three grammar-based methods: context-free grammar genetic programming (CFG-GP), including its variant GPHH recently applied to exam timetabling, grammatical evolution (GE), and LOGENPRO, it discusses how they solve the problems encountered by GP, and compares them in a series of experiments in six applications using success rates and derivation tree characteristics. The thesis demonstrates that neither GE nor LOGENPRO provide a substantial advantage over CFG-GP in any of the experiments, and analyses the differences between the effects of operators used in CFG-GP and GE. It also presents results from a highly efficient implementation of CFG-GP and GE.

One-sided random context grammars

Abstract: The notion of a one-sided random context grammar is defined as a context-free-based regulated grammar, in which a set of permitting symbols and a set of forbidding symbols are attached to every rule, and its set of rules is divided into the set of left random context rules and the set of right random context rules. A left random context rule can rewrite a nonterminal if each of its permitting symbols occurs to the left of the rewritten symbol in the current sentential form while each of its forbidding symbols does not occur there. A right random context rule is applied analogically except that the symbols are examined to the right of the rewritten symbol. The paper demonstrates that without erasing rules, one-sided random context grammars characterize the family of context-sensitive languages, and with erasing rules, these grammars characterize the family of recursively enumerable languages. In fact, these characterization results hold even if the set of left random context rules coincides with the set of right random context rules. Several special cases of these grammars are considered, and their generative power is established. In its conclusion, some important open problems are suggested to study in the future.

Formalizing Functional Flow Block Diagrams Using Process Algebra and Metamodels

Abstract: Functional flow block diagrams (FFBDs) are a traditional tool of systems engineering and remain popular in some systems engineering domains. However, their lack of formal definition makes FFBDs imprecise and impossible to rigorously analyze. The inability to analyze FFBDs may allow specification errors to remain undetected until well into the system design process or, worse, until the system is operational. To help address these problems, we have developed a precise formal syntax and semantics for FFBDs, based on the application of metamodels and the process algebra Communicating Sequential Processes (CSP). FFBDs constructed within our formalized framework are precisely defined and amenable to analyses of properties, such as safety, progress, and conformance to required scenarios. We demonstrate some of the analyses made possible by our formalization in a simple case study of system specification and show how our formalization can be used to detect and correct subtle system errors during the specification phase.

Methods and systems for parsing and interpretation of mathematical statements

Abstract: Methods, systems, and devices are described that provide for entry of hybrid mathematical and natural language statements in a mathematical notation friendly language and system for a rigorous yet practically tractable formal grammar to distill the essence of natural math notation. Hybrid statements mixing natural language and symbolic expressions including assertions, commands, queries, and/or deductions may be entered that are processed according to natural language processing. The statements, along with the math objects are evaluated, and one or more results output. Furthermore, systems may provide automatic construction of one or more solution narratives that can be beneficial to student users pedagogically.

Recent Progresses in the Linguistic Modeling of Biological Sequences Based on Formal Language Theory

Abstract: Treating genomes just as languages raises the possibility of producing concise generalizations about information in biological sequences. Grammars used in this way would constitute a model of underlying biological processes or structures, and that grammars may, in fact, serve as an appropriate tool for theory formation. The increasing number of biological sequences that have been yielded further highlights a growing need for developing grammatical systems in bioinformatics. The intent of this review is therefore to list some bibliographic references regarding the recent progresses in the field of grammatical modeling of biological sequences. This review will also contain some sections to briefly introduce basic knowledge about formal language theory, such as the Chomsky hierarchy, for non-experts in computational linguistics, and to provide some helpful pointers to start a deeper investigation into this field.

Consensual languages and matching finite-state computations

Abstract: An ever present, common sense idea in language modelling research is that, for a word to be a valid phrase, it should comply with multiple constraints at once. A new language definition model is studied, based on agreement or consensus between similar strings. Considering a regular set of strings over a bipartite alphabet made by pairs of unmarked/marked symbols, a match relation is introduced, in order to specify when such strings agree. Then a regular set over the bipartite alphabet can be interpreted as specifying another language over the unmarked alphabet, called the consensual language. A word is in the consensual language if a set of corresponding matching strings is in the original language. The family thus defined includes the regular languages and also interesting non-semilinear ones. The word problem can be solved in NLOGSPACE, hence in P time. The emptiness problem is undecidable. Closure properties are proved for intersection with regular sets and inverse alphabetical homomorphism. Several conditions for a consensual definition to yield a regular language are presented, and it is shown that the size of a consensual specification of regular languages can be in a logarithmic ratio with respect to a DFA. The family is incomparable with context-free and tree-adjoining grammar families.

Computer-based construction of arbitrarily complex formal grammar expressions

Abstract: A method, system and computer program product for building an expression, including utilizing any formal grammar of a context-free language, displaying an expression on a computer display via a graphical user interface, replacing at least one non-terminal display object within the displayed expression with any of at least one non-terminal display object and at least one terminal display object, and repeating the replacing step a plurality of times for a plurality of non-terminal display objects until no non-terminal display objects remain in the displayed expression, wherein the non-terminal display objects correspond to non-terminal elements within the grammar, and wherein the terminal display objects correspond to terminal elements within the grammar.

An Extension of DNA Splicing System

Abstract: The first mathematical model of a splicing system that was analyzed in the framework of Formal Language Theory was developed in 1987 by Head. This model consists of a finite alphabet, a finite set of initial strings over the alphabet, and a finite set of rules that act upon the strings by iterated cutting and pasting, generating new strings. In this paper, a new notation for writing rules in a splicing system and a new extension of splicing systems is introduced in order to make the biological process transparent. These are called Yusof-Goode rules, and they are associated with Yusof-Goode splicing systems. Four different classes of splicing systems are discussed: null-context, uniform, simple and SkH systems. Also, counterexamples are given to illustrate relationships between these splicing system classes.

Model Checking Probabilistic Real-Time Properties for Service-Oriented Systems with Service Level Agreements

Abstract: The assurance of quality of service properties is an important aspect of service-oriented software engineering. Notations for so-called service level agreements (SLAs), such as the Web Service Level Agreement (WSLA) language, provide a formal syntax to specify such assurances in terms of (legally binding) contracts between a service provider and a customer. On the other hand, formal methods for verification of probabilistic real-time behavior have reached a level of expressiveness and efficiency which allows to apply them in real-world scenarios. In this paper, we suggest to employ the recently introduced model of Interval Probabilistic Timed Automata (IPTA) for formal verification of QoS properties of service-oriented systems. Specifically, we show that IPTA in contrast to Probabilistic Timed Automata (PTA) are able to capture the guarantees specified in SLAs directly. A particular challenge in the analysis of IPTA is the fact that their naive semantics usually yields an infinite set of states and infinitely-branching transitions. However, using symbolic representations, IPTA can be analyzed rather efficiently. We have developed the first implementation of an IPTA model checker by extending the PRISM tool and show that model checking IPTA is only slightly more expensive than model checking comparable PTA.

Adv-EARS: A Formal Requirements Syntax for Derivation of Use Case Models

Abstract: The development of complex systems frequently involves extensive work to elicit, document and review functional requirements that are usually written in unconstrained natural language, which is inherently imprecise. Use of Formal techniques in Requirement Engineering would be of immense importance as it would provide automated support in deriving use case models from the functional requirements. In this paper we propose a formal syntax for requirements called Adv-EARS. We define a grammar for this syntax such that a requirements document in this format can be grammatically parsed and the prospective actors and use cases are automatically derived from the parse tree. The use case diagram is then automatically generated based on the actors and use cases and their relationships. We have used requirements of an Insurance system as a case study to illustrate our approach.

Formal language constrained reachability and model checking propositional dynamic logics

Abstract: We show interreducibility under (Turing) reductions of low polynomial degree between three families of problems parametrised by classes of formal languages: the problem of reachability in a directed graph constrained by a formal language, the problem of deciding whether or not the intersection of a language of some class with a regular language is empty, and the model checking problem for Propositional Dynamic Logic over some class of formal languages. This allows several decidability and complexity results to be transferred, mainly from the area of formal languages to the areas of modal logics and formal language constrained reachability.

Effects of Formal “Grammar” and “Direct Method” Training on the Number of Errors in Compositions Written by Sixth-Graders

Abstract: This study evaluated the effectiveness of “formal grammar” and “direct method” traming designed to reduce the number of errors in capitalization, conjunctions, subject. verb agreement, incomplete sentences and incorrectly joining independent clauses, that fine sixth-graders accumulated in their composition. The children were exposed to a sequence of (a) “formal grammar” training which consisted of a logically organized program of traditionai grammar instructions through the parts of speech, with stress on the function of the words, using a granunar textbook; (b) generalization writing sessions, and (e) writing sessions under “direct method” training in which no textbook or grammatical terminology was used; however, the ele. ments of sentence building and structure were treated as the teacher confronted them while the children were writing. The sequence, “formal grammar-direct method” training and “direct method” training, were effective procedures in reducing the children’s rate of errors compared to their baseline rates. These results suggest that “formal grammar” alone was lot effective enough to reduce the children’s rate of errors. However, the sequence, “formal grammar­direct method” training, proved to be a practical and efficient procedure to improve children’s writing.

A Tool for Model-Based Language Specification

Abstract: Formal languages let us define the textual representation of data with precision. Formal grammars, typically in the form of BNF-like productions, describe the language syntax, which is then annotated for syntax-directed translation and completed with semantic actions. When, apart from the textual representation of data, an explicit representation of the corresponding data structure is required, the language designer has to devise the mapping between the suitable data model and its proper language specification, and then develop the conversion procedure from the parse tree to the data model instance. Unfortunately, whenever the format of the textual representation has to be modified, changes have to propagated throughout the entire language processor tool chain. These updates are time-consuming, tedious, and error-prone. Besides, in case different applications use the same language, several copies of the same language specification have to be maintained. In this paper, we introduce a model-based parser generator that decouples language specification from language processing, hence avoiding many of the problems caused by grammar-driven parsers and parser generators.

Monolingual Dictionary Semantic Capturing Using Concept Lattice

Abstract: This paper proposes an approach for retrieving semantic relationships between semantic units in a monolingual dictionary. The presented approach is based on the usage of formal concept analysis (FCA) technique for determining semantic relations and hierarchy in a set of words extracted from dictionary. In the first phase the formal grammar for words and the extraction of their attributes from Croatian language monolingual dictionary is defined. In our approach grammar rules include graphical properties of dictionary text. In the second phase a technique of using formal concept analysis for the capturing of semantic overlapping is modeled. The models are represented in F-logic language and implemented using FLORA-2 system. The focus of this paper is on the whole transformation process of a set of words from the dictionary into the concept lattice. The concept lattice as the final result shows semantic relationships and overlapping in a set of words.

Constraint Based Syntax of Modifiers

Abstract: The paper introduces a technique for grammar rules that licence post-and pre-modified phrases, by using a generalized approach to constraint based lexicalized grammar. The rules generate iterative modification by avoiding spurious syntactic ambiguity. The rules of syntactic modification are lexically restricted by the lexical head of the modifier expression via a grammatical feature and its value.

Formal Parsing Analysis of Context-Free Grammar using Left Most Derivations

Abstract: Formal approaches are useful to verify the properties of software and hardware systems. Formal verification of a software system targets the source program where semantics of a language has more meanings than its syntax. Therefore, program verification does not give guarantee the generated executable code is correct as described in the source program. This is because the compiler may lead to an incorrect target program due to bugs in the compiler itself. It means verification of compiler is important than verification of a source program to be compiled. In this paper, context-free grammar is linked with Z notation to be useful in the verification of a part of compiler. At first, we have defined grammar, then, language derivation procedure is described using the left most derivations. In the next, verification of a given language is described by recursive procedures. The ambiguity of a language is checked as a part of the parsing analysis. The formal specification is analyzed and validated using Z/Eves tool. Formal proofs of the models are presented using powerful techniques, that is, reduction and rewriting of the Z/Eves. Keywords-parsing analysis; context-free language; formal specification; Z notation; verification.

On Nondeterminism in Programmed Grammars

Abstract: In the present paper, we discuss programmed grammars. More specif-ically, we discuss their nondeterministic behavior and its reduction. Weprove that for every programmed grammar, there exists an equivalent pro-grammed grammar where only a single rule has more than one successor.Furthermore, we establish an infinite hierarchy of language families result-ing from the cardinality of successor sets. Open problem areas are formu-lated in the conclusion of the paper. 1 Introduction A programmed grammar (see [3, 12]), G, is a context-free grammar, in which aset of rules—called successors—is attached to each rule. G can apply a rule r inthe following way. If the left-hand side ofr occurs in the sentential form underscan, G rewrites the left-hand side ofr to its right-hand side, and during the nextderivation step, it has to apply a rule from the set attached to r.Since their introduction, programmed grammars have represented a vividlystudied area of formal language theory, as demonstrated by several recent studies,such as [1, 2, 4–9]. Although this theory has established their fundamental proper-ties (see [3, 10, 13] for a highlight of crucially important results), the precise roleof nondeterminism in programmed grammars has not been studied to its fullness.In [1] and [2], it is proved that (a) if we require every rule in a programmed gram-mar to have at most one successor, then we can generate only fin ite languages,and (b) any programmed grammar can be converted to an equivalent programmedgrammar with every rule having at most two successors. Also, other related re-sults are proved in there. However, to our knowledge, there has been no study in316

Context-Free Systems with a Complementarity Relation

Abstract: Motivated by the studies on Watson-Crick finite automata and Watson-Crick L systems, we introduce a generative device known as a Watson-Crick context-free system (WKCFS) making use of a complementarity relation and a context-free type of rewriting on double-stranded strings with the symbols in the string in the lower strand complementary to the symbols of the string in the upper strand. The language generated by a WKCFS is the set of all strings in the upper strands of the double-stranded strings (u, v) generated such that the strings u, v are of the same length and the corresponding symbols in the strings u, v are related by the complementarity relation. We compare the generative power of WKCFS with some families of languages and also certain variants of Watson-Crick finite automata.