Functional dependencies on extended relations defined by regular languages

In the document-centric modeling of information systems, the flow of data between individual documents and the collections stored in the database plays an important role. The types of data that can be stored in the collections and their constraints are given by the data models supported by the database management software. We show the semantically fundamental usage difference between the documents and the database. In addition to managing relational rows, the relational data model that is the most important starting point also contains a basic document type, namely the tabular document type, as a representation of a relation consisting of relatively few rows. With this dual task in mind, we introduce the extended relational model. In the standard relational model, each relation name identifies a collection of occurrences of a single row type. Therefore, in schema-level instructions and operations, each relation name/table name has a fixed set of attributes (ordered or unordered). In our paper, we introduce a collection containing tables of different but similar schemas. Actions can be specified at this level, which applies to several tables at the same time. The similarity of the schemes is given by belonging to a formal language over a finite set of attribute names. Every sentence of a given formal language can be a potential schema. An attribute name can therefore occur more than once in a specific schema, and the order is fixed. An instance of a schema collection consists of a finite number of table types. This is called an extended relation. Among the formal languages, we first discuss the use of regular languages. In the case of context-free languages, we use the language's terminal and non-terminal symbols as attribute names. With this, embedded relational schemas can also be handled. We use graph representations of formal languages as schema graphs. With the help of this, we specify the operations at the schema and instance level. The definition and implication problems of functional dependencies are investigated too. We show the close connection with the XML ELEMENT declaration. We also specify an implementation solution. After introduction, we shortly examine its use in the document centric modelling of information systems. A novel X-merge solution is specified between free documents and X-relations.

In this paper, we first rephrase the notion of extended tuple as a sentence from a regular language generated by a grammar G where the nonterminal symbols of the grammar are the attribute names of the tuple. Finite sets of extended tuples play the role of extended relation instances. Then we introduce the dual language, which generates the accepted tuple-types of the extended relation. We define the syntactical form of functional dependencies for extended relation on the graph of the finite state automaton associated to the dual language. Using this model we can handle extended relations generated by recursive regular expressions too. The implication problem of our class of dependencies is decidable by a version of Chase algorithm specified on the graph of the associated FSA.KeywordsFunctional DependencyRegular ExpressionIntegrity ConstraintRegular LanguageState AutomatonThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

To deal with issues of data model transformation and to make combined use of different data models, this paper proposed a database reengineering scheme which includes schema translation and data conversion from object-oriented data model to flattened XML data model with is-a and cardinality data semantics preservation. In this paper, conceptual schema of object-oriented data model and flattened XML data model are elaborated by UML class diagram and XML Schema Definition(XSD) graph respectively. Logical schema is described by UNISQL class definition and XSD respectively. This paper firstly analyzes class definitions from OODB and sorts them from most independent classes to most dependent classes. Secondly schema translation is processed by mapping class to complexType and then creating element definitions in XSD file. Thirdly data conversion is processed automatically. Performance tests have shown that the proposed database reengineering scheme is reliable and efficient.

It is well known that the set of powers of any given order, for example squares, in a regular language need not be regular. Nevertheless, finite automata can identify them via their roots. More precisely, we recall that, given a regular language L, the set of square roots of L is regular. The same holds true for the nth roots for any n and for the set of all nontrivial roots; we give a concrete construction for all of them. Using the above result, we obtain decision algorithms for many natural problems on powers. For example, it is decidable, given two regular languages, whether they contain the same number of squares at each length. Finally, we give an exponential lower bound on the size of automata identifying powers in regular languages. Moreover, we highlight interesting behavior differences between taking fractional powers of regular languages and taking prefixes of a fractional length. Indeed, fractional roots in a regular language can typically not be identified by finite automata.

In this chapter, the research background is discussed. This includes XML model, XML query languages, XML schema languages, XML Application Program Interface, XML documents types, XML data storage approaches, relational database model, and the similarities and differences between XML model and relational database model. Finally the chapter summary is given.

Decomposing relationship types by pivoting and schema equivalence

This chapter provides an introduction to the theory of regular languages and finite automata. These concepts will be used in the following chapters for describing behaviors of asynchronous circuits and for specifying abstract behaviors. The theory of regular languages and finite automata is now well established as one of the important basic tools of computer science. We present this theory in a somewhat different way than is done in most textbooks, because we feel that our approach is more general and permits us to establish the relationship between regular languages and finite automata in a very natural way. For a general introduction to regular languages and finite automata, see one of the many texts on this subject, for example [65, 77, 100, 120]; for material closer to our treatment see [16, 17, 20].

Part 1 Data modelling: a relational data model concepts of the relational data model, operations defined on a set of relations, normal operations defined on a set of instances, synthesis - data dictionary, example - production workshop, integrity rules integrity rule, introduction to dependencies, functional and dimensional dependencies, join and decomposition dependencies, inclusion dependencies, relation cycles, other integrity rules, table of ir ranges. Part 2 Transformations: introduction and access paths graph choice of an internal data model, accuracy of an internal structure, access paths graph, relation graph, join of embedded relations, plan of the second part, transformation of a decomposition into a relation graph, relation graph of a decomposition, use of hinges, from a relation graph to an internal data structure choice of an access paths graphs, computing methods of embedding access paths. Part 3 Decomposition of a relation: choosing a relation decomposition decomposing a relation, projection and extension of an integrity rule, qualities of a decomposition, choice crieria for a functional decomposition introduction, problems encountered, structural elements, a solution - mechanisms for completeness of keys and entities, basic decomposition introduction, keys to a relation, minimum fd equivalence classes, block of attributes and groups of fds, invariance of non-redundant bases, homogenous coverings and the basic covering, homogenous decompositions and the basic decomposition of a relation, completely homogenous decomposition, relation graph of a completely homogenous decomposition, FD appendix, Appendix: damping functional cycles damping a functional cycle, validation of a damping. Part 4 Perspectives: perspectives design process for databases, extended relational data model, control mechanisms, Appendix: use of this mechanism.

A database management system (DBMS) should provide capabilities for defining and enforcing certain integrity constraints that must hold for the data recorded in the database. These constraints are derived from the semantics of the data and from the rules of the system under study (SuS) that database represents. Every DBMS is based on a data model that provides the means to achieve data abstraction and to express database schema. Each data model has a specific set of integrity constraints types. Some of constraint types are common for several data models and some of them are typical for a data model. Beyond well-known constraint types there are more complex ones that are difficult to express and enforce within the data model. In this paper we deal with the extended tuple constraint (ETC) type. It is the extension of tuple constraint that is one of constraint types of relational data model. In this paper we explain the usage of extended tuple constraint in relational data model and its implementation in relational DBMSs. XML data model does not recognize ETC type. We specify the extended tuple constraint in XML data model and propose two techniques for implementation of ETC in XML DBMSs. Each of them depends on the characteristics of a selected XML DBMS. We use XQuery functions in eXist DBMS, and triggers in Sedna DBMS.

Finite state automata are of fundamental importance in theory as well as applications in computer science. This dissertation presents several parallel algorithms for processing of them, including minimizing the number of states for a given finite state automaton, finding homing sequences for a given finite state automaton, converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. Implementation of some algorithms, as well as their experimental results, are also given. For minimization of deterministic finite automata, we present a parallel algorithm and discuss its implementation on a practical parallel machine using data parallel and message passing paradigms. Its time complexity on a p processor EREW PRAM $(p\\le n)$ for inputs of size n is $O({n\\log\\sp2n\\over p}+\\log n\\ \\log p)$ uniformly on almost all instances. The work done by our algorithm is thus within a factor of $O(\\log n)$ of the best known sequential algorithm. The space used by our algorithm is linear in the input size. The actual resource requirements of our implementations are consistent with these estimates. For finding homing sequences of deterministic finite automata, we present both deterministic and randomized algorithms. Two randomized algorithms of time complexity $O(log\\sp2n)$ are given. One of the randomized algorithms produces a homing sequence of length $O(n\\ log\\sp2n)$ for almost all DFA's with n states. The deterministic algorithm is based on a well known sequential algorithm. The implementation of the deterministic parallel algorithm shows that it can handle randomly generated instances with millions of states, and all DFA's with thousands of states using currently available parallel machines. Finally, we present an efficient parallel algorithm for converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. The resulting automaton is natural representation of a regular expression and has some important and practical uses in the document processing area. The time complexity of the algorithm is $O(\\log n)$ and the number of processors used is $O(n\\sp2).$

Parallel communicating finite automata (PCFAs) are systems of several finite state automata which process a common input string in a parallel way and are able to communicate by sending their states upon request. We consider deterministic and nondeterministic variants and distinguish four working modes. It is known that these systems in the most general mode are as powerful as one-way multihead finite automata. It is additionally known that the number of heads corresponds to the number of automata in PCFAs in a constructive way. Thus, undecidability results as well as results on the hierarchies induced by the number of heads carry over from multi-head finite automata to PCFAs in the most general mode. Here, we complement these undecidability and hierarchy results also for the remaining working modes. In particular, we show that classical decidability questions are not semi-decidable for any type of PCFAs under consideration. Moreover, it is proven that the number of automata in the system induces infinite hierarchies for deterministic and nondeterministic PCFAs in three working modes.

The presence of a schema offers many advantages in processing, translating, querying, and storage of XML data. Basic decision problems like equivalence, inclusion, and non-emptiness of intersection of schemas form the basic building blocks for schema optimization and integration, and algorithms for static analysis of transformations. It is thereby paramount to establish the exact complexity of these problems. Most common schema languages for XML can be adequately modeled by some kind of grammar with regular expressions at right-hand sides. In this paper, we observe that apart from the usual regular operators of union, concatenation and Kleene-star, schema languages also allow numerical occurrence constraints and interleaving operators. Although the expressiveness of these operators remain within the regular languages, their presence or absence has significant impact on the complexity of the basic decision problems. We present a complete overview of the complexity of the basic decision problems for DTDs, XSDs and Relax NG with regular expressions incorporating numerical occurrence constraints and interleaving. We also discuss chain regular expressions and the complexity of the schema simplification problem incorporating the new operators.

Evaluation of Schema Languages: RNG and WXS on Interface Complexity Metric

Objective: The study of finite state automaton is an essential tool in machine learning and artificial intelligence. The class of rough finite state automaton captures the uncertainty using the rough transition map. The need to generalize this concept arises to adhere the dynamical behaviour of the system. Hence this paper focuses on defining non-homogeneous rough finite state automaton. Methodology: With the aid of Rough finite state automata we define the concept of non-homogeneous rough finite state automata. Findings: Non homogeneous Rough Finite State Automata (NRFSA) Mt is defined by a tuple (Q,Σ,δt,q0 (t),F(t)) The dynamical behaviour of any system can be expressed in terms of an information system at time t. This leads us to define non-homogeneous rough finite state automaton. For each time ‘t’ we generate lower approximation rough finite state automaton Mt_ and the upper approximation rough finite state automaton Mt- and the defined concepts are elaborated with suitable examples. The ordered pair , Mt=(M(t)-,M(t)-) is called as the non-homogeneous rough finite state automaton. Conclusion: Over all our study reveals the characterization of the system which changes its behaviour dynamically over a time ‘t’. Novelty: The novelty of the proposed article is that it clearly immense the system behaviour over a time ‘t’. Using this concept the possible and the definite transitions in the system can be calculated in any given time ‘t’.

Living systems process information using chemistry. Computations can be viewed as language recognition problems where both languages and automata recognizing them form an inclusive hierarchy. Chemical realizations, without using biochemistry, of the main classes of computing automata, Finite Automata (FA), 1-stack Push Down Automata (1-PDA) and Turing Machine (TM) have recently been presented. These use chemistry for the representation of input information, its processing and output information. The Turing machine uses the Belousov-Zhabotinsky (BZ) oscillatory reaction to recognize a representative Context-Sensitive Language (CSL), the 1-PDA uses a pH network to recognize a Context Free Language (CFL) and a FA for a Regular Language (RL) uses a precipitation reaction. By chemically reconfiguring them to recognize representative languages in the lower classes of the Chomsky hierarchy we illustrate the inclusiveness of the hierarchy of native chemical automata. These examples open the door for chemical programming without biochemistry. Furthermore, the thermodynamic metric originally introduced to identify the accept/reject state of the chemical output for the CSL, can equally be used for recognizing CFL and RL by the automata. Finally, we point out how the chemical and thermodynamic duality of accept/reject criteria can be used in the optimization of the energetics and efficiency of computations.