Language and automata theory and applications third international conference, LATA 2009, Tarragona, Spain, April 2-8, 2009, proceedings

Lecture Notes in Computer Science Commenced Publication in 1973 Founding and Former Series Editors: Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen

Editorial Board David Hutchison Lancaster University, UK Takeo Kanade Carnegie Mellon University, Pittsburgh, PA, USA Josef Kittler University of Surrey, Guildford, UK Jon M. Kleinberg Cornell University, Ithaca, NY, USA Alfred Kobsa University of California, Irvine, CA, USA Friedemann Mattern ETH Zurich, Switzerland John C. Mitchell Stanford University, CA, USA Moni Naor Weizmann Institute of Science, Rehovot, Israel Oscar Nierstrasz University of Bern, Switzerland C. Pandu Rangan Indian Institute of Technology, Madras, India Bernhard Steffen University of Dortmund, Germany Madhu Sudan Massachusetts Institute of Technology, MA, USA Demetri Terzopoulos University of California, Los Angeles, CA, USA Doug Tygar University of California, Berkeley, CA, USA Gerhard Weikum Max-Planck Institute of Computer Science, Saarbruecken, Germany

5457

Adrian Horia Dediu Armand Mihai Ionescu Carlos Martín-Vide (Eds.)

Language and Automata Theory and Applications Third International Conference, LATA 2009 Tarragona, Spain, April 2-8, 2009 Proceedings

13

Volume Editors Adrian Horia Dediu Research Group on Mathematical Linguistics Universitat Rovira i Virgili Tarragona, Spain E-mail: [email protected] Armand Mihai Ionescu Research Group on Mathematical Linguistics Universitat Rovira i Virgili Tarragona, Spain E-mail: [email protected] Carlos Martín-Vide European Research Council Executive Agency Brussels, Belgium E-mail: [email protected]

Library of Congress Control Number: Applied for CR Subject Classification (1998): F.4, I.1, I.5, F.1 LNCS Sublibrary: SL 1 – Theoretical Computer Science and General Issues ISSN ISBN-10 ISBN-13

0302-9743 3-642-00981-6 Springer Berlin Heidelberg New York 978-3-642-00981-5 Springer Berlin Heidelberg New York

This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer. Violations are liable to prosecution under the German Copyright Law. springer.com © Springer-Verlag Berlin Heidelberg 2009 Printed in Germany Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India Printed on acid-free paper SPIN: 12626878 06/3180 543210

Preface

These proceedings contain all the papers that were presented at the Third International Conference on Language and Automata Theory and Applications (LATA 2009), held in Tarragona, Spain, during April 2–8, 2009. The scope of LATA is rather broad, including: algebraic language theory; algorithms on automata and words; automata and logic; automata for system analysis and program verification; automata, concurrency and Petri nets; biomolecular nanotechnology; cellular automata; circuits and networks; combinatorics on words; computability; computational, descriptional, communication and parameterized complexity; data and image compression; decidability questions on words and languages; digital libraries; DNA and other models of bio-inspired computing; document engineering; extended automata; foundations of finite-state technology; fuzzy and rough languages; grammars (Chomsky hierarchy, contextual, multidimensional, unification, categorial, etc.); grammars and automata architectures; grammatical inference and algorithmic learning; graphs and graph transformation; language varieties and semigroups; language-based cryptography; language-theoretic foundations of natural language processing, artificial intelligence and artificial life; mathematical evolutionary genomics; parsing; patterns and codes; power series; quantum, chemical and optical computing; regulated rewriting; string and combinatorial issues in computational biology and bioinformatics; symbolic dynamics; symbolic neural networks; term rewriting; text algorithms; text retrieval, pattern matching and pattern recognition; transducers; trees, tree languages and tree machines; and weighted machines. LATA 2009 received 121 submissions, many among them of good quality. Each one was reviewed by at least three Program Committee members plus, in most cases, by additional external referees. After a thorough and vivid discussion phase, the committee decided to accept 58 papers (which means an acceptance rate of 47.93%). The conference program also included three invited talks and two invited tutorials. Part of the success in the management of such a large number of submissions is due to the excellent facilities provided by the EasyChair conference management system. We would like to thank all invited speakers and authors for their contributions, the reviewers for their cooperation and Springer for the collaboration and publication. January 2009

Adrian Horia Dediu Armand Mihai Ionescu Carlos Mart´ın-Vide

Organization

LATA 2009 was hosted by the Research Group on Mathematical Linguistics (GRLMC) at Rovira i Virgili University, Tarragona, Spain.

Program Committee Parosh Abdulla Stefania Bandini Stephen Bloom John Brzozowski Maxime Crochemore J¨ urgen Dassow Michael Domaratzki Henning Fernau Rusins Freivalds Vesa Halava Juraj Hromkoviˇc Lucian Ilie Kazuo Iwama Aravind Joshi Juhani Karhum¨ aki Jarkko Kari Claude Kirchner Maciej Koutny Hans-J¨org Kreowski Kamala Krithivasan Martin Kutrib Andrzej Lingas Aldo de Luca Rupak Majumdar Carlos Mart´ın-Vide (Chair) Joachim Niehren Antonio Restivo J¨ org Rothe Wojciech Rytter Philippe Schnoebelen Thomas Schwentick Helmut Seidl Alan Selman Jeffrey Shallit Frank Stephan

Uppsala, Sweden Milan, Italy Hoboken, USA Waterloo, Canada London, UK Magdeburg, Germany Winnipeg, Canada Trier, Germany Riga, Latvia Turku, Finland Zurich, Switzerland London, Canada Kyoto, Japan Philadelphia, USA Turku, Finland Turku, Finland Bordeaux, France Newcastle, UK Bremen, Germany Chennai, India Giessen, Germany Lund, Sweden Naples, Italy Los Angeles, USA Brussels, Belgium Lille, France Palermo, Italy D¨ usseldorf, Germany Warsaw, Poland Cachan, France Dortmund, Germany Munich, Germany Buffalo, USA Waterloo, Canada Singapore

VIII

Organization

External Reviewers Jean-Paul Allouche Carl Alphonce Marcella Anselmo Franz Baader M. Sakthi Balan Dorothea Baumeister Paul Bell Suna Bensch Clara Bertolissi Eike Best Henrik Bj¨ orklund Hans-Joachim B¨ockenhauer Mikolaj Boja´ nczyk Henning Bordihn Ahmed Bouajjani Pascal Bouvry Paul Brauner Anne Br¨ uggemann-Klein Michelangelo Bucci Arturo Carpi Giuseppa Castiglione Stephan K. Chalup Jan Chomicki Christine Choppy Hubert Comon-Lundh Christophe Costa Florˆencio Stefano Crespi Reghizzi Erzs´ebet Csuhaj-Varj´ u Flavio D’Alessandro Peter Damaschke Alessandro De Luca Herv´e Debar Giorgio Delzanno St´ephane Demri Alain Denise Jacques D´esarm´enien Chrysanne DiMarco Daniel Dougherty Jean-Philippe Dubernard Michael Emmi G´ abor Erd´elyi Pierre Ganty Florent Garnier Olivier Gauwin

Thomas Gawlitza Wouter Gelade Pierre Genev`es R´emi Gilleron Francesc Godoy Guillem Godoy Massimiliano Goldwurm Jean Goubault-Larrecq Hermann Gruber Stefan Gulan Frank Gurski Peter Habermehl Tero Harju Michael A. Harrison Pierre-Cyrille H´eam Mika Hirvensalo Markus Holzer Christopher Homan Florent Jacquemard Petr Jancar Ryszard Janicki Jesper Jansson Nataˇsa Jonoska Helmut J¨ urgensen Michael Kaminski Aleksandr Karbyshev Tomi K¨ arki Victor Khomenko Dennis Komm Adrian Kosowski Lukasz Kowalik Richard Kr´ alovic Bohuslav Krena Dalia Krieger Vladislav Kubon Aur´elien Lemay Alberto Leporati Martin Leucker Christos Levcopoulos Maria Madonia Kalpana Mahalingam Andreas Malcher Sabrina Mantaci Wim Martens

Organization

Tom´aˇs Masopust Giancarlo Mauri Ian McQuillan Massimo Merro Tommi Meskanen Tobias M¨ omke Debdeep Mukhopadhyay Aniello Murano Anca Muscholl Benedek Nagy Stefan N¨ aher N. S. Narayanaswamy Gonzalo Navarro Frank Neven Phong Q. Nguyen Damian Niwinski Thomas Noll Dirk Nowotka Ulrik Nyman Mitsunori Ogihara Alexander Okhotin Friedrich Otto Matteo Palmonari Elisabeth Pelz Mia Persson ´ Jean-Eric Pin Sophie Pinchinat Wojciech Plandowski Denis Poitrenaud Ely Porat Igor Potapov Sylvia Pott Raghavan Rama Narad Rampersad

Silvio Ranise Kenneth W. Regan Andreas Reuss Christophe Reutenauer Magnus Roos Giovanna Rosone David Sabel Martin Schwarz Marinella Sciortino Sebastian Seibert David James Sherman Nataliya Skrypnyuk Holger Spakowski Andreas Sprock Monika Steinov´ a Martin Sulzmann Siamak Taati Isabelle Tellier Pascal Tesson John Thistle Ralf Treinen Bianca Truthe Otto Urpelainen Gy¨ orgy Vaszil Masilamani Vedhanayagam Kumar Neeraj Verma Stephan Waack Osamu Watanabe Bruce W. Watson James Worrell Menno van Zaanen Hans Zantema Louxin Zhang ˙ nski Pawel Zyli´

Organizing Committee M˘ ad˘ alina Barbaiani Gemma Bel-Enguix Adrian Horia Dediu Szil´ ard-Zsolt Fazekas Armand Mihai Ionescu Maria Dolores Jim´enez-L´opez Alexander Krassovitskiy Guangwu Liu

Carlos Mart´ın-Vide (Chair) Zolt´an-P´ al Mecsei Robert Merca¸s C˘at˘ alin-Ionut¸ Tˆırn˘ auc˘ a Cristina Tˆırn˘ auc˘ a Bianca Truthe Sherzod Turaev Florentina-Lilica Voicu

IX

Table of Contents

Invited Talks Recent Developments in Algorithmic Teaching . . . . . . . . . . . . . . . . . . . . . . . Frank J. Balbach and Thomas Zeugmann Monadic Second-Order Logic for Graphs: Algorithmic and Language Theoretical Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bruno Courcelle

1

19

Descriptional and Computational Complexity of Finite Automata . . . . . . Markus Holzer and Martin Kutrib

23

Hypothesis Spaces for Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sanjay Jain

43

State Complexity of Nested Word Automata . . . . . . . . . . . . . . . . . . . . . . . . Kai Salomaa

59

Regular Papers A Language-Based Comparison of Extensions of Petri Nets with and without Whole-Place Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Parosh Aziz Abdulla, Giorgio Delzanno, and Laurent Van Begin Minimal Union-Free Decompositions of Regular Languages . . . . . . . . . . . . Sergey Afonin and Denis Golomazov Commutative Regular Shuffle Closed Languages, Noetherian Property, and Learning Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Yohji Akama

71 83

93

Matching Trace Patterns with Regular Policies . . . . . . . . . . . . . . . . . . . . . . Franz Baader, Andreas Bauer, and Alwen Tiu

105

Absolute Convergence of Rational Series Is Semi-decidable . . . . . . . . . . . . Rapha¨el Bailly and Fran¸cois Denis

117


2 [REG] . . . . . . . . . . . . . Non-solvable Groups Are Not in FO+MOD+MAJ Christoph Behle, Andreas Krebs, and Stephanie Reifferscheid

129

Reoptimization of Traveling Salesperson Problems: Changing Single Edge-Weights . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tobias Berg and Harald Hempel

141

XII

Table of Contents

Refinement and Consistency of Timed Modal Specifications . . . . . . . . . . . Nathalie Bertrand, Sophie Pinchinat, and Jean-Baptiste Raclet Nondeterministic Instance Complexity and Proof Systems with Advice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Olaf Beyersdorff, Johannes K¨ obler, and Sebastian M¨ uller How Many Holes Can an Unbordered Partial Word Contain? . . . . . . . . . . Francine Blanchet-Sadri, Emily Allen, Cameron Byrum, and Robert Merca¸s An Answer to a Conjecture on Overlaps in Partial Words Using Periodicity Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Francine Blanchet-Sadri, Robert Merca¸s, Abraham Rashin, and Elara Willett

152

164 176

188

Partial Projection of Sets Represented by Finite Automata, with Application to State-Space Visualization . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bernard Boigelot and Jean-Fran¸cois Degbomont

200

Larger Lower Bounds on the OBDD Complexity of Integer Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beate Bollig

212

Picture Languages Generated by Assembling Tiles . . . . . . . . . . . . . . . . . . . Paola Bonizzoni, Claudio Ferretti, Anthonath Roslin Sagaya Mary, and Giancarlo Mauri Undecidability of Operation Problems for T0L Languages and Subclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Henning Bordihn, Markus Holzer, and Martin Kutrib

224

236

Decision Problems for Convex Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . Janusz Brzozowski, Jeffrey Shallit, and Zhi Xu

247

On a Family of Morphic Images of Arnoux-Rauzy Words . . . . . . . . . . . . . . Michelangelo Bucci and Alessandro De Luca

259

Monadic Datalog Tree Transducers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Matthias B¨ uchse and Torsten St¨ uber

267

On Extended Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benjamin Carle and Paliath Narendran

279

Multi-tilde Operators and Their Glushkov Automata . . . . . . . . . . . . . . . . Pascal Caron, Jean-Marc Champarnaud, and Ludovic Mignot

290

Non-uniform Cellular Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gianpiero Cattaneo, Alberto Dennunzio, Enrico Formenti, and Julien Provillard

302

Table of Contents

A Cryptosystem Based on the Composition of Reversible Cellular Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Adam Clarridge and Kai Salomaa

XIII

314

Grammars Controlled by Special Petri Nets . . . . . . . . . . . . . . . . . . . . . . . . . J¨ urgen Dassow and Sherzod Turaev

326

Nested Counters in Bit-Parallel String Matching . . . . . . . . . . . . . . . . . . . . . Kimmo Fredriksson and Szymon Grabowski

338

Bounded Delay and Concurrency for Earliest Query Answering . . . . . . . . Olivier Gauwin, Joachim Niehren, and Sophie Tison

350

Learning by Erasing in Dynamic Epistemic Logic . . . . . . . . . . . . . . . . . . . . Nina Gierasimczuk

362

The Fault Tolerance of NP-Hard Problems . . . . . . . . . . . . . . . . . . . . . . . . . . Christian Glaßer, A. Pavan, and Stephen Travers

374

Termination of Priority Rewriting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Isabelle Gnaedig

386

State Complexity of Combined Operations for Prefix-Free Regular Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Yo-Sub Han, Kai Salomaa, and Sheng Yu

398

Towards a Taxonomy for ECFG and RRPG Parsing . . . . . . . . . . . . . . . . . . Kees Hemerik

410

Counting Parameterized Border Arrays for a Binary Alphabet . . . . . . . . . Tomohiro I, Shunsuke Inenaga, Hideo Bannai, and Masayuki Takeda

422

Bounded Hairpin Completion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Masami Ito, Peter Leupold, and Victor Mitrana

434

Rigid Tree Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Florent Jacquemard, Francis Klay, and Camille Vacher

446

Converting Self-verifying Automata into Deterministic Automata . . . . . . Galina Jir´ askov´ a and Giovanni Pighizzini

458

Two Equivalent Regularizations for Tree Adjoining Grammars . . . . . . . . . Anna Kasprzik

469

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm for Weighted Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aude Liefooghe, H´el`ene Touzet, and Jean-St´ephane Varr´e

481

Membership Testing: Removing Extra Stacks from Multi-stack Pushdown Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nutan Limaye and Meena Mahajan

493

XIV

Table of Contents

Automata on Gauss Words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Alexei Lisitsa, Igor Potapov, and Rafiq Saleh

505

Analysing Complexity in Classes of Unary Automatic Structures . . . . . . . Jiamou Liu and Mia Minnes

518

An Application of Generalized Complexity Spaces to Denotational Semantics via the Domain of Words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Jordi Llull-Chavarr´ıa and Oscar Valero

530

Segmentation Charts for Czech – Relations among Segments in Complex Sentences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mark´eta Lopatkov´ a and Tom´ aˇs Holan

542

A Note on the Generative Power of Some Simple Variants of Context-Free Grammars Regulated by Context Conditions . . . . . . . . . . . . Tom´ aˇs Masopust

554

Efficiency of the Symmetry Bias in Grammar Acquisition . . . . . . . . . . . . . Ryuichi Matoba, Makoto Nakamura, and Satoshi Tojo

566

A Series of Run-Rich Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wataru Matsubara, Kazuhiko Kusano, Hideo Bannai, and Ayumi Shinohara

578

On Accepting Networks of Evolutionary Processors with at Most Two Types of Nodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Victor Mitrana and Bianca Truthe

588

The Halting Problem and Undecidability of Document Generation under Access Control for Tree Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Neil Moore

601

Prediction of Creole Emergence in Spatial Language Dynamics . . . . . . . . Makoto Nakamura, Takashi Hashimoto, and Satoshi Tojo

614

On the Average Size of Glushkov’s Automata . . . . . . . . . . . . . . . . . . . . . . . . Cyril Nicaud

626

Tiling the Plane with a Fixed Number of Polyominoes . . . . . . . . . . . . . . . . Nicolas Ollinger

638

New Morphic Characterizations of Languages in Chomsky Hierarchy Using Insertion and Locality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kaoru Onodera

648

On Parallel Communicating Grammar Systems and Correctness Preserving Restarting Automata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dana Pardubsk´ a, Martin Pl´ atek, and Friedrich Otto

660

Table of Contents

XV

Finitely Generated Synchronizing Automata . . . . . . . . . . . . . . . . . . . . . . . . . Elena V. Pribavkina and Emanuele Rodaro

672

Genetic Algorithm for Synchronization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Adam Roman

684

Constructing Infinite Words of Intermediate Arithmetical Complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Paul V. Salimov

696

From Gene Trees to Species Trees through a Supertree Approach . . . . . . Celine Scornavacca, Vincent Berry, and Vincent Ranwez

702

A Kleene Theorem for Forest Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lutz Straßburger

715

Determinization and Expressiveness of Integer Reset Timed Automata with Silent Transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P. Vijay Suman and Paritosh K. Pandya

728

One-Clock Deterministic Timed Automata Are Efficiently Identifiable in the Limit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sicco Verwer, Mathijs de Weerdt, and Cees Witteveen

740

Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

753

Recent Developments in Algorithmic Teaching Frank J. Balbach1 and Thomas Zeugmann2 1 Neuhofen, Germany [email protected] 2 Division of Computer Science Hokkaido University, Sapporo 060-0814, Japan [email protected]

Abstract. The present paper surveys recent developments in algorithmic teaching. First, the traditional teaching dimension model is recalled. Starting from the observation that the teaching dimension model sometimes leads to counterintuitive results, recently developed approaches are presented. Here, main emphasis is put on the following aspects derived from human teaching/learning behavior: the order in which examples are presented should matter; teaching should become harder when the memory size of the learners decreases; teaching should become easier if the learners provide feedback; and it should be possible to teach infinite concepts and/or finite and infinite concept classes. Recent developments in the algorithmic teaching achieving (some) of these aspects are presented and compared.

1

Introduction

When preparing a lecture, a good teacher is carefully selecting informative examples. Additionally, a good teacher is taking into account that students do not memorize everything previously taught. And usually we make a couple of assumptions about the learners. They should neither be ignorant, lazy, nor should they be tricky. Thus, it is only natural to ask whether or not such human behavior is at least partially reflected in some algorithmic learning and/or teaching models studied so far in the literature. Learning concepts from examples has attracted considerable attention in learning theory and machine learning. Typically, a learner does not know much about the source of these examples. Usually the learner is required to learn from all such sources, regardless of their quality. This is even true for the query learning model introduced by Angluin [1,2], since the teacher or oracle, though answering truthfully, is assumed to behave adversarially whenever possible. Therefore, it was only natural to ask whether or not one can also model scenarios in which a helpful teacher is honestly interested in the learner’s success. Perhaps the first approach was proposed by Freivalds, Kinber, and Wiehagen [3,4]. They developed a learning model in the inductive inference paradigm of identifying recursive functions in which the learner is provided with good examples chosen by an implicitly given teacher. Jain, Lange, and Nessel [5] adopted A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 1–18, 2009. c Springer-Verlag Berlin Heidelberg 2009 

2

F.J. Balbach and T. Zeugmann

this model to learn recursively enumerable languages from good examples in the inductive inference paradigm. The next step was to consider teaching as the natural counterpart of learning. Teaching has been modeled and investigated in various ways within algorithmic learning theory. However, the more classical models studied so far all follow one of two basically different approaches. In the first approach, the goal is to find a teacher and a learner such that a given learning task can be carried out by them. Jackson and Tomkins [6] as well as Goldman and Mathias [7,8] defined models of teacher/learner pairs where teachers and learners are constructed explicitly. In all these models, some kind of adversary disturbing the teaching process is necessary to avoid collusion between the teacher and the learner. That is, when modeling teaching, a major problem consists in avoiding coding tricks. Though there is no generally accepted definition of coding tricks, it will be clear from our exposition that no form of coding tricks is used and thus no collusion occurs. Angluin and Krik¸is’ [9,10] model prevents collusion by giving incompatible hypothesis spaces to teacher and learner. This makes simple encoding of the target impossible. In the second approach, a teacher has to be found that teaches all deterministic consistent learners. Here a learner is said to be consistent if its hypothesis is correctly reflecting all examples received. This prevents collusion, since teaching happens the same way for all learners and cannot be tailored to a specific one. Goldman, Rivest, and Shapire [11] and Goldman and Kearns [12] substitute the adversarial teacher in the online learning model by a helpful one selecting good examples. They investigate how many mistakes a consistent learner can make in the worst case. In Shinohara and Miyano’s [13] model the teacher produces a set of examples for the target concept such that it is the only consistent one in the concept class. The size of this set is the same as the worst case number of mistakes in the online model. This number is termed the teaching dimension of the target. Because of this similarity we shall from now on refer to both models as the teaching dimension model (abbr. TD model). One difficulty of teaching in the TD model results from the fact that the teacher is not knowing anything about the learners besides them being consistent. In reality a teacher can benefit a lot from knowing the learners’ behavior or their current hypotheses. It is therefore natural to ask how teaching can be improved if the teacher may observe the learners’ hypotheses after each example. We refer to this scenario as to teaching with feedback. After translating this question into the TD model, one sees that there is no gain in sample size at all. The current hypothesis of a consistent learner reveals nothing about its following hypothesis. Even if the teacher knew the hypothesis and provided a special example in response, he can only be sure that the learner’s next hypothesis will be consistent. But this was already known to the teacher. So, in the TD model, feedback is useless. There are also several other deficiencies in the teaching models studied so far. These deficiencies include that the order in which the teacher presents examples

Recent Developments in Algorithmic Teaching

3

does not matter, and that teaching infinite concepts or infinite concept classes is severely limited. Another drawback is the rather counterintuitive dependence on the memory size of the learner. If the learner’s memory size is large enough to store all examples provided by the teacher, then successful teaching is possible. Otherwise, it immediately becomes impossible. Another problem is that there are concept classes which are intuitively easy to teach that have a large teaching dimension. Therefore, our goal has been to devise teaching models that remedy the above mentioned flaws. In particular, our aim has been to develop teaching models such that the following aspects do matter. (1) The order in which the teacher presents the information should have an influence on the performance of the teacher. (2) Teaching should get harder when the memory size of the learners decreases, but it should not become impossible for small memory. (3) Teaching should get easier when the learners give feedback to the teacher. (4) Concepts that are more complex should be harder to teach. (5) The teaching model should work for both finite and infinite concepts and/or finite and infinite concept classes. We studied and developed several models of algorithmic teaching to overcome these flaws to a different extent (cf. [14,15,16,17,18]). Within the present paper, we shortly summarize our and the related results obtained. The paper is organized as follows. Section 2 shortly recalls the TD model and fundamental definitions needed subsequently. Then we discuss more recent approaches. In Section 3 we summarize results concerning teaching learners that have to obey restrictions on possible mind changes. Next, we turn our attention to a randomized model of teaching (see Section 4). Finally, we shortly touch teaching dimensions for complexity based learners and for cooperative learning.

2

The Teaching Dimension Model

We start by introducing the necessary notions and definitions. Let N = {0, 1, . . .} denote the set of all natural numbers. For any set S we write |S| to denote its cardinality. Let X be any (finite) set of instances also called instance space. A concept c is a subset of X and a concept class C is a set of concepts over X. It is convenient to identify every concept c with its characteristic function, i.e., for all x ∈ X we have c(x) = 1 if x ∈ c and c(x) = 0 otherwise. We consider mainly three instance spaces: {0, 1}n for Boolean functions, Σ ∗ for languages over a finite and non-empty alphabet Σ, and Xn = {x1 , . . . , xn } for having any fixed instance space of cardinality n. By X = X × {0, 1} we denote the set of examples over X. An example (x, b) is either positive, if b = 1, or negative, if b = 0. A concept c is consistent with a set S = {(x1 , b1 ), . . . , (xn , bn )} of examples iff c(xi ) = bi for all i = 1, . . . , n. In the TD model, a learning algorithm takes as input a set S of examples for a concept c ∈ C and computes a hypothesis h. As mentioned in the Introduction, we

4

F.J. Balbach and T. Zeugmann

have to restrict the set of admissible learners. A consistent and class preserving learning algorithm is only allowed to choose the hypotheses from the set H(S) = {h ∈ C | h is consistent with S} . A teaching set 1 for a concept c with respect to C is a set S of examples such that c is the only concept in C consistent with S, i.e., H(S) = {c} (cf. [12,11]). The teaching dimension TD(c) is the size of the smallest teaching set for c, the teaching dimension of C is TD(C) = max{TD(c) | c ∈ C} .

(1)

Consequently, the teaching dimension of a concept c determines the number of examples needed by an optimal teacher for teaching c to all consistent and class preserving learning algorithms. So in the TD model the information theoretic complexity of teaching is reduced to a combinatorial parameter. Note that the teaching dimension has been calculated for many natural concept classes such as (monotone) monomials, monotone k-term DNFs, k-term μ-DNFs, monotone decision lists and rectangles in {0, 1, . . . , n − 1}d (cf. [12]); for linearly separable Boolean functions (cf. [21,22]); for threshold functions (cf. [13]); and for k-juntas and sparse GF2 polynomials (cf. [23]). Since the teaching dimension does depend exclusively on the concept class, it has also been compared to other combinatorial parameters studied in learning theory. These parameters comprise the query complexity in Angluin’s [2] query learning model, the VC-dimension and parameters studied in the online learning model (cf. Heged˝ us [24,25], Ben-David and Eiron [26], and Rivest and Yin [27]). Despite its succinctness and elegance, the teaching dimension has also drawbacks. For seeing this, let us consider the following example. Fix any natural number n ≥ 2 and define the concept class Sn = {c0 , c1 , . . . , cn } over Xn as follows: c0 = ∅ as well as ci = {xi } for all i = 1, . . . , n. Then we have TD(ci ) = 1 for all i = 1, . . . , n, since the single positive example (xi , 1) is sufficient for teaching ci . Nevertheless, TD(c0 ) = n, since there are at least two consistent hypotheses until all n negative examples have been presented to the learners. Thus, TD(Sn ) = n despite the fact that the class Sn seems rather simple. However, the teaching dimension is the maximum possible. Similar effects can be observed for the class of all monomials, all 2-term DNFs, all 1-decision lists, and all Boolean functions (over {0, 1}n), since all these classes have the same teaching dimension, i.e., 2n . 2.1

The Average Teaching Dimension

As we have shortly outlined, the teaching dimension does not always capture our intuition about the difficulty to teach concepts. One reason for the implausibility of the results sometimes obtained is due to the fact that the teaching dimension of the class is determined by the worst case teaching dimension over all concepts. 1

Note that a teaching set is also called key [13], discriminant [19] and witness set [20].

Recent Developments in Algorithmic Teaching

5

Thus, all easily learnable concepts are not taken into account. So a natural remedy is to consider the average teaching dimension instead of the worst case teaching dimension. Definition 1. Let C be a concept class. The average teaching dimension of C is 1 defined as TD(C) = |C| c∈C TD(c). Looking again at the class Sn defined above, we directly see that TD(Sn ) =

n+n·1 TD(c∗ ), Eμ− (c∗ ) ≥ Eμ+ (c∗ ) ≥ TD(c∗ )/2. Now, we take a closer look at learners with feedback. For the sake of presentation we start with learners with 1-memory. A teaching process involving L+ 1 can be modeled as an MDP with S = C∪{init}, A = X (c∗ ), cost (h, z) = 1 for h = c∗ and cost (c∗ , z) = 0. Furthermore, for h = c∗ , p(h, z, h ) = 1/|C(z)| if z ∈ X (h )\X (h) and p(h, z, h ) = 0 otherwise; finally p(c∗ , z, c∗ ) = 1 (see [30,29]). The initial state is init and the state c∗ is costless and absorbing. The memory is not part of the state, since the next hypothesis only depends on the newly given example which is modeled as an action. An example z ∈ X (h) does not change the learner’s state h and is therefore useless. An optimal teacher refrains from teaching such examples and thus we can derive the following criterion. Lemma 20. Let C be a concept class over X and let c∗ be a target. A teacher T : C ∪ {init} → X (c∗ ) with expectations H : C ∪ {init} → is optimal iff for all h ∈ C ∪ {init}: ⎛ ⎞  1 T (h) ∈ argmin ⎝1 + H(h )⎠ . |C(z)|  z∈X (c∗ ) z ∈X / (h)

h ∈C(z)

This criterion can be used to prove optimality for teaching algorithms. We compare E1+ with other dimensions. The comparison of E1+ with the number MQ of membership queries (see Angluin [1]) is interesting because MQ and E1+ are both lower bounded by the teaching dimension. Fact 21 (1) For all C and c∗ ∈ C: E1+ (c∗ ) ≥ TD(c∗ ). (2) There is no function of TD upper bounding E1+ (c). (3) There is no function of E1+ upper bounding MQ . (4) There is a concept class C with E1+ (C) > MQ(C). (5) For all concept classes C, E1+ (C) ≤ 2MQ(C) . Roughly speaking, teaching L+ 1 can take arbitrarily longer than teaching in the classical model, but is still incomparable with membership query learning. We finish this subsection by looking at learners with ∞-memory. A straight∗ ≤|X| . forward MDP for teaching c∗ to L+ ∞ has states S = (C ∪ {init}) × X (c ) The number of states can be reduced because two states (h, m) and (h, m ) with C(m) = C(m ) are equivalent from a teacher’s perspective, but in general the size of the resulting MDP will not be polynomial in the size of the matrix representation of C. Therefore, optimal teachers cannot be computed efficiently by the known general MDP algorithms.

Recent Developments in Algorithmic Teaching

15

A similar criterion as Lemma 20 can be stated for the L+ ∞ learner, too, and used to prove optimality of algorithms. Note that there is always a teacher that + ∗ needs at most TD(c∗ ) rounds by giving a minimal teaching set, hence E∞ (c ) ≤ ∗ + ∗ ∗ TD(c ). Second, it follows from Lemma 19 that E∞ (c ) ≥ TD(c )/2. This means + ∗ that every algorithm computing E∞ (c ) also computes a factor 2 approximation of the teaching dimension. As it has often been noted [13,21,12], the problem of computing the teaching dimension is essentially equivalent to the SET-COVER (or HITTING-SET) problem which is a difficult approximation problem. Raz and Safra [31] have shown that there is no polynomial time constant-factor approximation (unless P = N P). Moreover, Feige [32] proved that SET-COVER cannot be approximated better than within a logarithmic factor (unless N P ⊆ DTime(nlog log n )). + is N P-hard and Corollary 22. Unless N P ⊆ DTime(nlog log n ), computing E∞ cannot be approximated with a factor of (1 − ) log(|C|) for any > 0.

However, we have: Fact 23. Let C be a concept class and c∗ ∈ C a target. Then there is a successful teacher for the learner L+ ∞ halting after at most |X| rounds that is also optimal. Note that our model of teaching a randomized learner also allows for studying teaching from positive data only. The interested reader is referred to [18] for details. Here we only mention the following topological characterization. Theorem 24. Let C be a concept class and c∗ ∈ C a target concept. Then for all learners Lσμ with μ ∈ [1, ∞], σ ∈ {+, −}: The concept c∗ is teachable from positive data iff there is no c ∈ C with c ⊃ c∗ . Studying the teachability of randomized learners without feedback is much harder, since the problem of finding the optimal cost in an MDP whose states are not observable is much more difficult. We refer the interested reader to Balbach and Zeugmann [17] for results in this regard.

5

Further Directions

A number of variations of the teaching dimension have been studied in which the learner is assumed to act smarter than just choosing a consistent hypothesis. One such model (see Balbach [14,15]) assumes the learner picks hypotheses that are not only consistent but of minimal complexity. This model is inspired by the Occam’s razor principle. A teacher that exploits this learning behavior can make do with fewer examples than in the original teaching dimension model. For example, 2-term DNFs and 1-decision lists can be taught with O(n) examples, as opposed to 2n examples (n being the number of variables). Note that this model presupposes a measure of complexity for all concepts in the class, such as

16

F.J. Balbach and T. Zeugmann

the length of a decision list or the number of terms in a DNF. But there might not be a unique, natural complexity measure for a given class. Another variant devised by Balbach [15] assumes that the learners know the teaching dimensions of all concepts in the class and choose their hypotheses only from the consistent ones with a teaching dimension at least as large as the sample given by the teacher. In other words, they assume the teacher does not give more examples than necessary for the concept to be taught. This optimal teacher teaching dimension (OTTD) model demands more of the learners, as they need to know all the teaching dimensions, but reduces the number of examples compared to the plain teaching dimension. For example, the OTTD of monomials is linear √ in the number of variables, and the OTTD of 1-decision lists is bounded √ by Ω( n · 2n/2 ) and O(n log n · 2n/2 ). If the learners in the OTTD model base their reasoning on the OTTD rather than the teaching dimension, one obtains yet another dimensionality measure. Intuitively, the learners assume that the teacher knows how they think and adjusts the sample he gives. Now the teacher can exploit this new behavior of the students, again reducing the number of examples needed. This gives rise to a series of decreasing dimensionality notions which, for finite concept classes, will eventually converge. In a similar vein, Zilles, Lange, Holte, and Zinkevich [33] defined a teaching model which is based on cooperative learners. Here the learners are assumed to know all minimal teaching sets for all concepts in the class, and they always choose from the consistent hypotheses a minimal teaching set which contains all examples given so far. In other words they assume that at all times the sample given by the teacher can be extended to a minimal teaching set for the concept to be taught. This demands even more of the learners than the OTTD, as they now have to know all minimal teaching sets of all concepts. In a similar way as above, this idea can be iterated, yielding a series of dimensionality notions that converge to one called the subset teaching dimension (STD). The STD is a lower bound for the iterated OTTDs. Zilles et al. [33] show a number of surprising properties of the STD. For example, the STD of the class of monomials is two, independent of the number of variables. A surprising property of the STD is its nonmonotonicity, that is, the STD of some classes is less than that of one of their subclasses. Finally, Zilles et al. [33] devise a dimensionality notion called the recursive teaching dimension (RTD), which combines the easy teachability of the monomials in the STD model with the property of monotonicity in the TD and OTTD models. However, it is not based on refined assumptions about the learners’ behavior and only measures the teachability of an entire concept class, not that of individual concepts. The basic idea is to order the concepts in a class and determine the teaching dimension of each concept with respect only to the class of all following concepts. The maximum teaching dimension for any concept minimized over all possible orderings determines the RTD of the class. The RTD is a lower bound for all iterated OTTDs, but its precise relationship to the STD is unknown. The STD is conjectured to be a lower bound for the RTD.

Recent Developments in Algorithmic Teaching

17

References 1. Angluin, D.: Queries and concept learning. Machine Learning 2, 319–342 (1988) 2. Angluin, D.: Queries revisited. Theoret. Comput. Sci. 313, 175–194 (2004) 3. Freivalds, R., Kinber, E.B., Wiehagen, R.: Inductive inference from good examples. In: Jantke, K.P. (ed.) AII 1989. LNCS (LNAI), vol. 397, pp. 1–17. Springer, Heidelberg (1989) 4. Freivalds, R., Kinber, E.B., Wiehagen, R.: On the power of inductive inference from good examples. Theoret. Comput. Sci. 110, 131–144 (1993) 5. Jain, S., Lange, S., Nessel, J.: On the learnability of recursively enumerable languages from good examples. Theoret. Comput. Sci. 261, 3–29 (2001) 6. Jackson, J., Tomkins, A.: A computational model of teaching. In: Proc. 5th Annual ACM Workshop on Computational Learning Theory, pp. 319–326. ACM Press, New York (1992) 7. Goldman, S.A., Mathias, H.D.: Teaching a smarter learner. J. of Comput. Syst. Sci. 52, 255–267 (1996) 8. Mathias, H.D.: A model of interactive teaching. J. of Comput. Syst. Sci. 54, 487– 501 (1997) 9. Angluin, D., Krik¸is, M.: Teachers, learners and black boxes. In: Proceedings of the Tenth Annual Conference on Computational Learning Theory, pp. 285–297. ACM Press, New York (1997) 10. Angluin, D., Krik¸is, M.: Learning from different teachers. Machine Learning 51, 137–163 (2003) 11. Goldman, S.A., Rivest, R.L., Schapire, R.E.: Learning binary relations and total orders. SIAM J. Comput. 22, 1006–1034 (1993) 12. Goldman, S.A., Kearns, M.J.: On the complexity of teaching. J. of Comput. Syst. Sci. 50, 20–31 (1995) 13. Shinohara, A., Miyano, S.: Teachability in computational learning. New Generation Computing 8, 337–348 (1991) 14. Balbach, F.J.: Teaching classes with high teaching dimension using few examples. In: Auer, P., Meir, R. (eds.) COLT 2005. LNCS (LNAI), vol. 3559, pp. 668–683. Springer, Heidelberg (2005) 15. Balbach, F.J.: Measuring teachability using variants of the teaching dimension. Theoret. Comput. Sci. 397, 94–113 (2008) 16. Balbach, F.J., Zeugmann, T.: Teaching learners with restricted mind changes. In: Jain, S., Simon, H.U., Tomita, E. (eds.) ALT 2005. LNCS (LNAI), vol. 3734, pp. 474–489. Springer, Heidelberg (2005) 17. Balbach, F.J., Zeugmann, T.: Teaching memoryless randomized learners without feedback. In: Balc´ azar, J.L., Long, P.M., Stephan, F. (eds.) ALT 2006. LNCS (LNAI), vol. 4264, pp. 93–108. Springer, Heidelberg (2006) 18. Balbach, F.J., Zeugmann, T.: Teaching randomized learners. In: Lugosi, G., Simon, H.U. (eds.) COLT 2006. LNCS (LNAI), vol. 4005, pp. 229–243. Springer, Heidelberg (2006) 19. Natarajan, B.K.: Machine Learning: A Theoretical Approach. Morgan Kaufmann, San Mateo (1991) 20. Kushilevitz, E., Linial, N., Rabinovich, Y., Saks, M.: Witness sets for families of binary vectors. Journal of Combinatorial Theory Series A 73, 376–380 (1996) 21. Anthony, M., Brightwell, G., Cohen, D., Shawe-Taylor, J.: On exact specification by examples. In: Proc. 5th Annual ACM Workshop on Computational Learning Theory, pp. 311–318. ACM Press, New York (1992)

18

F.J. Balbach and T. Zeugmann

22. Anthony, M., Brightwell, G., Shawe-Taylor, J.: On specifying Boolean functions by labelled examples. Discrete Applied Mathematics 61, 1–25 (1995) 23. Lee, H., Servedio, R.A., Wan, A.: DNF are teachable in the average case. In: Lugosi, G., Simon, H.U. (eds.) COLT 2006. LNCS, vol. 4005, pp. 214–228. Springer, Heidelberg (2006) 24. Heged˝ us, T.: Combinatorial results on the complexity of teaching and learning. In: Privara, I., Ruˇziˇcka, P., Rovan, B. (eds.) MFCS 1994. LNCS, vol. 841, pp. 393–402. Springer, Heidelberg (1994) 25. Heged˝ us, T.: Generalized teaching dimensions and the query complexity of learning. In: Proc. 8th Annual Conference on Computational Learning Theory, pp. 108– 117. ACM Press, New York (1995) 26. Ben-David, S., Eiron, N.: Self-directed learning and its relation to the VCdimension and to teacher-directed learning. Machine Learning 33, 87–104 (1998) 27. Rivest, R.L., Yin, Y.L.: Being taught can be faster than asking questions. In: Proc. 8th Annual Conference on Computational Learning Theory, pp. 144–151. ACM Press, New York (1995) 28. Kuhlmann, C.: On teaching and learning intersection-closed concept classes. In: Fischer, P., Simon, H.U. (eds.) EuroCOLT 1999. LNCS, vol. 1572, pp. 168–182. Springer, Heidelberg (1999) 29. Puterman, M.L.: Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Chichester (1994) 30. Bertsekas, D.P.: Dynamic Programming and Optimal Control. Athena Scientific (2001) 31. Raz, R., Safra, S.: A sub-constant error-probability low-degree test, and a subconstant error-probability PCP characterization of NP. In: Proc. of the 29th ACM Symposium on Theory of Computing, pp. 475–484. ACM Press, New York (1997) 32. Feige, U.: A threshold of ln n for approximating set cover. J. of the ACM 45, 634–652 (1998) 33. Zilles, S., Lange, S., Holte, R., Zinkevich, M.: Teaching dimensions based on cooperative learning. In: 21st Annual Conference on Learning Theory - COLT 2008, Helsinki, Finland, pp. 135–146. Omnipress (2008)

Monadic Second-Order Logic for Graphs: Algorithmic and Language Theoretical Applications Bruno Courcelle Universit´e Bordeaux-1, LaBRI, CNRS Institut Universitaire de France 351, Cours de la Lib´eration 33405, Talence cedex, France [email protected]

Abstract. This tutorial will present an overview of the use of Monadic Second-Order Logic to describe sets of finite graphs and graph transformations, in relation with the notions of tree-width and clique-width. It will review applications to the construction of algorithms, to Graph Theory and to the extension to graphs of Formal Language Theory concepts.

We first explain the role of Logic. A graph, either finite or infinite, can be considered as a logical structure whose domain (the ground set of the logical structure) consists of the set of vertices; a binary relation on this set represents adjacency. Graph properties can be expressed by logical formulas of different languages and classified accordingly. First-order formulas are rather weak in this respect because they can only express local properties, like having degree or diameter at most k for fixed k. Most properties of interest in Graph Theory can be expressed in second-order logic (this language allows quantifications on relations of arbitrary but fixed arity), but unfortunately, little can be obtained from such expressions. Second-order formulas that only use quantifications on unary relations, i.e., on sets are Monadic second-order formulas. They can express many basic and useful graph properties like connectivity, k-colorability, planarity and minor inclusion, just to take a few examples. These properties are said to be monadic second-order expressible and the corresponding sets of graphs are called monadic second-order definable. Many algorithmic properties follow from such logical descriptions. In particular, every monadic second-order definable set of finite graphs of bounded tree-width has a linear time recognition algorithm ([1], [2], [3], [4], [5]). Monadic second-order formulas are also used in Formal Language Theory to describe languages, i.e., sets of words or terms. A fundamental result in this field is that monadic second-order formulas and finite automata have the same expressive power. It is fundamental for the theory and practice of model-checking, 

Supported by the GRAAL project of “Agence Nationale pour la Recherche”.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 19–22, 2009. c Springer-Verlag Berlin Heidelberg 2009 

20

B. Courcelle

and, in Language Theory, it helps to analyze and classify the regular languages, i.e., those defined by finite automata. Monadic second-order formulas are even more important for describing sets of graphs than for describing languages because there is no convenient notion of graph automaton. They can also replace finite automata for defining graph transformations, that we call transductions, as in Language Theory. However, monadic second-order logic alone yields no interesting results. As mentioned above every monadic second-order graph property has, for each k, a polynomial time checking algorithm for graphs of tree-width at most k. No such algorithm can exist for arbitrary graphs, otherwise P=NP because 3-colorability is expressible by a monadic second-order formula. The checking problem for every monadic second-order graph property is nevertheless fixed parameter tractable (FPT ) for tree-width as parameter. (See [4], [5] on this notion). Hence in order to be useful, the expression of a graph property by a monadic second-order formula must be coupled with constraints on the considered graphs like having bounded tree-width, or with other constraints that are also based on appropriate types of hierarchical decompositions. Clique-width is another graph parameter, based on certain graph decompositions, that yields FPT algorithms for monadic second-order expressible properties ([2], [6], [7]). Tree-width and clique-width are important for language theoretical issues as well as for the construction of polynomial algorithms. It is convenient to formalize the hierarchical graph decompositions that yield the notions of tree-width and clique-width and fit with monadic second-order logic, as algebraic terms written with appropriate graph operations that generalize the concatenation of words. The value of such a term t is a finite graph G and t is one of its hierarchical decompositions of the considered type. The subterms of t define (roughly speaking) combinations of larger and larger subgraphs of G. This fact justifies the use of the word “hierarchical” in the above description. Sets of finite graphs can be described as subsets of certain graph algebras, by means of notions of Universal Algebra that are already known in Language Theory. Two of these notions are those of an equational and of a recognizable set of elements of an algebra. In the monoid of words, the corresponding classes of sets are respectively those of context-free and of regular languages. The notion of an equational set generalizes to arbitrary algebras the well-known Least-Fixed Point Characterization of context-free languages, and that of a recognizable set generalizes the characterization of regular languages in terms of finite congruences. Many properties of equational and recognizable sets of graphs are just particular instances of results that hold in arbitrary algebras, but others are particular to the considered algebras of graphs. Finite graphs can thus be handled in two ways. The “logical way” characterizes graphs “from inside”, that is, in terms of what they are made of and contain: vertices, edges, paths, minors, subgraphs. The “algebraic way” characterizes sets of graphs in a global way : a graph is treated as an element of an algebra and related with other elements of the same algebra, that are not necessarily among its subgraphs. Two important theorems relate these two approaches. The

Monadic Second-Order Logic for Graphs

21

Recognizability Theorem says that every set of finite graphs that is monadic second-order definable is recognizable. The Equationality Theorem says that a set of finite graphs is equational if and only if it is the set of graphs “definable inside finite trees” by a fixed finite tuple of monadic second-order formulas : we will say : “is the image of a set of finite trees under a monadic second-order transduction”. It follows from the Recognizability Theorem that, for a graph G defined by a term t (relative to an appropriate graph algebra), one can check in time O(|t|) whether or not G satisfies a fixed monadic second-order property. It follows also that the graphs of an equational set that satisfy a fixed monadic second-order property (like planarity) form an equational set. We call this result the Filtering Theorem. It generalizes the classical fact that the intersection of a context-free language with a regular one is context-free. Since the emptiness of an equational set is decidable, we get as a corollary that the monadic second-order satisfiability problem is decidable for every equational set L . This means that one can decide whether or not a given monadic second-order formula is satisfied by some graph in L. The Equationality Theorem entails that the family of equational sets of graphs is preserved under monadic second-order transductions. This corollary is similar to the fact that the image of a context-free language under a rational transduction is context-free. (A rational transduction can be specified by a nondeterministic finite-state transducer, and if the image of every word is a finite set, then it is also a monadic second-order transduction). The corollary follows from the fact that the class of monadic second-order transductions is closed under composition. The Recognizability and the Equationality Theorem contribute to establishing the foundations of a sound and robust extension of the theory of formal languages intended to cover descriptions of sets of finite graphs, and in which monadic second-order logic plays a major role. From the above informal statements, this extension may seem to be straightforward. However, general graphs are intrinsically more complex than words and terms, and some results do not extend. Let us give two examples. The set of all finite graphs is not equational, whereas the set of all words on a finite alphabet is (trivially) context-free. There are uncountably many recognizable sets of graphs, and this fact forbids any characterization of these sets in terms of graph automata, that would generalize a classical characterization of regular languages. These examples reflect the fact that the sets of graph operations upon which Recognizability and Equationality are based are infinite, and that this infiniteness is unavoidable. According to the above presentation, monadic second-order formulas expressing graph properties do not use edge set quantifications. This is due to the chosen representation of a graph by a relational structure. If we replace a graph G by its incidence (bipartite) graph Inc(G), where each edge is made into a vertex and where the adjacency relation edgInc(G) (e, v) expresses that a vertex v of G is an end of edge e, then monadic second-order formulas to be interpreted in Inc(G) can use edge set quantifications. A graph property is MS2 -expressible if it is expressible by a monadic second-order formula on incidence graphs. This variant of

22

B. Courcelle

monadic second-order logic has strictly more expressive power than the initially defined language. The existence of a perfect matching is MS2 -expressible but not monadic second-order expressible. However, the two variants of monadic secondorder logic have the same expressive power on words, on trees and on certain classes of graphs like those of planar graphs or, for each k, of graphs of degree at most k. The Recognizability Theorem and the Equationality Theorem have thus two versions, relative to the two possible representations of graphs by relational structures and to two different graph algebras. The graph algebra corresponding to MS2 -formulas, called the HR algebra, is the one with graph operations that express tree-decompositions and characterize tree-width. The one corresponding to monadic second-order formulas without edge set quantifications is called the VR algebra, it defines clique-width. The acronyms HR and VR refer respectively to hyperedge replacement and vertex replacement because the equational sets of the HR and of the VR algebras are the sets of graphs generated by certain context-free graph grammars called respectively hyperdege replacement and vertex replacement graph grammars. (See [1] and the first two chapters of the same volume.) These results are also interesting for Structural Graph Theory, i.e., for the study of graph decompositions, of embeddings of graphs on surfaces, of forbidden configuration characterizations, of colorings expressed as homomorphisms between graphs. Quick proofs that certain graph classes have bounded treewidth or clique-width can be obtained from the Equationality Theorem. All these definitions and results are in a book in preparation [2].

References 1. Courcelle, B.: The expression of graph properties and graph transformations in monadic second-order logic. In: Rozenberg, G. (ed.) Handbook of Graph Grammars and Computing by Graph Transformations. Foundations, vol. 1, pp. 313–400. World Scientific, Singapore (1997) 2. Courcelle, B.: Graph structure and monadic second-order logic. In: Book in preparation. Cambridge University Press, Cambridge (2009), http://www.labri.fr/perso/courcell/ActSci.html 3. Courcelle, B., Mosbah, M.: Monadic second-order evaluations on tree-decomposable graphs. Theor. Comput. Sci. 109, 49–82 (1993) 4. Downey, R., Fellows, M.: Parameterized Complexity. Springer, Heidelberg (1999) 5. Flum, J., Grohe, M.: Parameterized Complexity Theory. Springer, Heidelberg (2006) 6. Courcelle, B., Makowsky, J., Rotics, U.: Linear time solvable optimization problems on graphs of bounded clique-width. Theory Comput. Syst. 33, 125–150 (2000) 7. Makowsky, J.: Algorithmic uses of the feferman-vaught theorem. Ann. Pure Appl. Logic 126, 159–213 (2004)

Descriptional and Computational Complexity of Finite Automata Markus Holzer and Martin Kutrib Institut f¨ ur Informatik, Universit¨ at Giessen, Arndtstr. 2, 35392 Giessen, Germany {holzer,kutrib}@informatik.uni-giessen.de

Abstract. Over the last half century, a vast literature documenting the importance of deterministic, nondeterministic, and alternating finite automata as an enormously valuable concept has been developed. In the present paper, we tour a fragment of this literature. Mostly, we discuss developments relevant to finite automata related problems like, for example, (i) simulation of and by several types of finite automata, (ii) standard automata problems such as, e.g., fixed and general membership, emptiness, universality, equivalence, and related problems, and (iii) minimization and approximation. We thus come across descriptional and computational complexity issues of finite automata. We do not prove these results but we merely draw attention to the big picture and some of the main ideas involved.

1

Introduction

Nondeterministic finite automata (NFAs) were introduced in [59], where their equivalence to deterministic finite automata (DFAs) was shown. Later the concept of alternation was developed in [10], where also alternating finite automata (AFAs) were investigated, which turned out to be equivalent to DFAs, too. Many work has been done in the study of descriptional complexity of simulation of and by several types of automata and on the computational complexity of decision problems related to finite automata. The goal of this research is to obtain tight bounds on simulation results and to classify the computational complexity of problems according to the complexity classes NC1 , L, NL, P, NP, and PSPACE, or others—for basics in computational complexity theory we refer to, e.g., [33]. Our tour on the subjects listed in the abstract of finite automata related problems cover some (recent) results in the field of descriptional and computational complexity. It obviously lacks completeness and it reflects our personal view of what constitute the most interesting links to descriptional and computational complexity theory. In truth there is much more to the regular languages, DFAs, NFAs, etc., than one can summarize here. For a recent survey on finite automata we refer to [68] and [30]. Our nomenclature of finite automata is as follows: The powerset of a set Q is denoted by 2Q and the empty word by λ. A nondeterministic finite automaton (NFA) is a quintuple A = (Q, Σ, δ, q0 , F ), where Q is the finite set of states, Σ A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 23–42, 2009. c Springer-Verlag Berlin Heidelberg 2009 

24

M. Holzer and M. Kutrib

is the finite set of input symbols, q0 ∈ Q is the initial state, F ⊆ Q is the set of accepting states, and δ : Q × Σ → 2Q is the transition function. A finite automaton is deterministic (DFA) if and only if |δ(q, a)| = 1, for all states q ∈ Q and letters a ∈ Σ. In this case we simply write δ(q, a) = p instead of δ(q, a) = {p} assuming that the transition function is a mapping δ : Q × Σ → Q. So, any DFA is complete, that is, the transition function is total, whereas it may be a partial function for NFAs in the sense that the transition function of nondeterministic machines may map to the empty set. The language accepted by the NFA or DFA A is defined as L(A) = { w ∈ Σ ∗ | δ(q0 , w) ∩ F = ∅ }, where the transition function is recursively extended to δ : Q × Σ ∗ → 2Q . A finite automaton is said to be minimal if its number of states is minimal with respect to the accepted language. Note that a sink state is counted for DFAs, since they are always complete, whereas it is not counted for NFAs, since these devices are not necessarily complete. For further details we refer to [33]. We identify the logical values false and true with 0 and 1 and write {0, 1}Q Q for the set of finite functions from Q into {0, 1}, and {0, 1}{0,1} for the set of Boolean formulas (functions) mapping {0, 1}Q into {0, 1}. An alternating finite automaton (AFA) is a quintuple A = (Q, Σ, δ, q0 , F ), where Q, Σ, q0 , and F are Q as for NFAs, and δ : Q × Σ → {0, 1}{0,1} is the transition function. The transition function maps pairs of states and input symbols to Boolean formulas. Before we define the language accepted by the AFA A we have to explain how a word is accepted. As the input is read (from left to right), the automaton “builds” a propositional formula, starting with the formula q0 , and on reading an input a, replaces every q ∈ Q in the current formula by δ(q, a). The input is accepted if and only if the constructed formula on reading the whole input evaluates to 1 on substituting 1 for q, if q ∈ F , and 0 otherwise. This substitution defines a mapping from Q into {0, 1} which is called the characteristic vector fA of A. Then the language accepted by A is defined as L(A) = { w ∈ Σ ∗ | w is accepted by A }. Two automata are equivalent if and only if they accept the same language. For further details we refer to [10] and [33].

2

Descriptional Complexity of Finite Automata Simulations

Since regular languages have many representations in the world of finite automata, it is natural to investigate the succinctness of their representation by different types of automata in order to optimize the space requirements. Here we measure the costs of representations in terms of the states of a minimal automaton accepting a language. More precisely, the simulation problem is defined as follows: – Given two classes of finite automata C1 and C2 , how many states are sufficient and necessary in the worst case to simulate n-state automata from C1 by automata from C2 ? In particular, we are interested in simulations between DFAs, NFAs, and AFAs.

Descriptional and Computational Complexity of Finite Automata

25

It is well known that to any NFA one can always construct an equivalent DFA [59]. This so-called powerset construction, where each state of the DFA is associated with a subset of NFA states, turned out to be optimal, in general. That is, the bound on the number of states necessary for the construction is tight in the sense that for an arbitrary n there is always some n-state NFA which cannot be simulated by any DFA with strictly less than 2n states [56,58]. So, NFAs can offer exponential saving in the number of states compared with DFAs. This gives rise to the following theorem. Theorem 1 (NFA by DFA Simulation). Let n ≥ 1 and A be an n-state NFA. Then 2n states are sufficient and necessary in the worst case for a DFA to accept L(A). The situation becomes more involved when AFAs come into play. Alternating finite automata as we have defined them have been developed in [10]. At the same period in [9] the so-called Boolean automata were introduced. Note, that several authors use the notation “alternating finite automata” but rely on the definition of Boolean automata. Though it turned out that both types are almost identical, there are differences with respect to the initial configurations. While for AFAs the computation starts with the fixed propositional formula q0 , a Boolean automaton starts with an arbitrary propositional formula. Clearly, this does not increase their computational capacities. However, it might make a difference of one state from a descriptional complexity point of view when simulating a Boolean automaton by an AFA. It is an open problem whether or not the additional state is really necessary, that is, whether the bound of n + 1 is tight. Next we turn to the simulation of AFAs by NFAs and DFAs. The tight bound n of 22 states for the deterministic simulation of n-state AFAs has already been shown in the famous fundamental papers [10] for AFAs and [9,50] for Boolean automata. Theorem 2 (AFA by DFA Simulation). Let n ≥ 1 and A be an n-state n AFA or Boolean automaton. Then 22 states are sufficient and necessary in the worst case for a DFA to accept L(A). The original proofs of the upper bound rely on the fact that an AFA or a Boolean automaton can enter only finitely many internal situations, which are given by Boolean functions depending on n Boolean variables associated with the n states. n The number of 22 such functions determines the upper bound. In [17] the constructions of simulating NNFAs are presented which implies the same upper bound. Basically, an NNFA is an NFA with multiple entry states, where initially one is nondeterministically chosen. The basic idea is that the NNFA simulates the AFA or Boolean automaton A by guessing the sequence of functions of the form {0, 1}Q that appear during the evaluation of the propositional formula computed by the A in reverse order. Since there are 2n such functions we obtain the upper bound stated in Theorem 3. Moreover, since the powerset constructions works also fine for the NNFA by DFA simulation, the

26

M. Holzer and M. Kutrib

presented construction also reveals the upper bound for the AFA simulation by DFAs already stated in Theorem 2. It is known that any NNFA can be simulated by an NFA having one more state. The additional state is used as new sole initial state which is appropriately connected to the successors of the old initial states. On the other hand, in general this state is needed. Nevertheless, it is an open problem whether there are languages accepted by n-state AFAs or Boolean automata such that any equivalent NFA has at least 2n + 1 states. In [17] it is conjectured that this bound presented in the following theorem is tight. Theorem 3 (AFA by NNFA and NFA Simulation). Let n ≥ 1 and A be an n-state AFA or Boolean automaton. Then 2n states are sufficient and necessary in the worst case for an NNFA to accept L(A). Moreover, 2n + 1 states are sufficient for an NFA to accept L(A), and for every n ≥ 1 there is an n-state AFA or Boolean automaton A such that any NFA accepting L(A) has at least 2n states. The matching lower bound of Theorem 2 is shown in [10] for AFAs by witness languages in a long proof. Before we come back to this point for Boolean automata, we turn to an interesting aspect of AFAs and Boolean automata. One can observe that the construction of the simulating NNFA is backward deterministic [10]. So, the reversal of a language accepted by an n-state AFA or Boolean automaton is accepted by a not necessarily complete 2n -state DFA which in turn can be simulated by a (2n + 1)-state complete DFA. This result has significantly be strengthened in [50], where it is shown that the reversal of every n-state DFA language is accepted by a Boolean automaton with log2 (n) states. With other words, with restriction to reversals of regular languages a Boolean automaton can always save exponentially many states compared with a DFA. The next theorem summarizes these results. Theorem 4 (Reversed AFA by DFA Simulation). Let n ≥ 1 and A be an n-state AFA or Boolean automaton. Then 2n + 1 states are sufficient and necessary in the worst case for a DFA to accept the reversal of L(A). If the minimal DFA accepting the reversal of L(A) does not have a rejecting sink state, then 2n states are sufficient. Moreover, the reversal of every language accepted by an n-state DFA is accepted by a Boolean automaton with log2 (n) states. The theorem lefts open whether the reversal of every n-state DFA language is also accepted by some AFA with log2 (n) states. However, we know that log2 (n) + 1 states are sufficient for this purpose. Now we are prepared to argue for the matching lower bound of Theorem 2 for Boolean automata in a simple way. It is well known that for any m ≥ 1 there is an m-state DFA A such that any DFA accepting the reversal of L(A) has 2m states [50]. Setting m = 2n we obtain a 2n -state DFA language L(A) whose reversal is accepted by a Boolean automaton with n states by Theorem 4. n On the other hand, the reversal of L(A) takes at least 22 states to be accepted deterministically.

Descriptional and Computational Complexity of Finite Automata

27

Next we argue that the upper bound of Theorem 3 cannot be improved in general. To this end, let A be an n-state AFA or Boolean automaton such that n any equivalent DFA has 22 states. Let m be the minimal number of states for an equivalent NNFA. Since the NNFA can be simulated by a DFA with at most 2m n states, we conclude 2m ≥ 22 , that is, the NNFA has at least m ≥ 2n states. We now direct our attention to the question whether alternation can always help to represent a regular language succinctly. It is well known that nondeterminism cannot help for all languages. So, how about the worst case of the language representation by alternating finite automata? The situation seems to be more sophisticated. Theorem 4 says that for reversals of n-state DFA languages we can always achieve an exponential saving of states. Interestingly, this potential gets lost when we consider the n-state DFA languages itself (instead of their reversals). The next theorem and its corollary are from [51]. Theorem 5. For every n ≥ 1 there exists a minimal DFA A with n states such that any AFA or Boolean automaton accepting L(A) has at least n states. The DFAs An = ({q0 , q1 , . . . , qn−1 }, {a, b}, δ, q1, F ) witness the theorem for n ≥ 2, where F = { qi | 0 ≤ i ≤ n − 1 and i even } and the transition function given by  for 0 ≤ i ≤ n − 3 qi δ(qi , a) = q(i+1) mod n and δ(qi , b) = qn−1 for i ∈ {n − 2, n − 1}. Each DFA An has the property that any DFA An accepting the reversal of L(A) has at least 2n states. Moreover, An and An both are minimal, complete and do not have a rejecting sink state [50]. Assume that L(A) is accepted by some AFA or Boolean automaton with m < n states. Then the reversal of L(A) would be accepted by some DFA having at most 2m states by Theorem 4. This is a contradiction since 2m < 2n . Up to now we dealt with simulations whose costs optimality is witnessed by regular languages which may be built over alphabets with two or more letters. For the particular case of unary regular languages, that is, languages over a single letter alphabet, the situation turned out to be significantly different. The problem of evaluating the costs of unary automata simulations was raised in [61], and has led to emphasize some relevant differences with the general case. So, we next turn to draw a part of that picture, which is complemented by the sophisticated studies in [55] which reveal tight bounds also for many other types of finite automata and, in addition, is a valuable source for further references. For state complexity issues of unary finite automata Landau’s function F (n) = max{ lcm(x1 , . . . , xk ) | x1 , . . . , xk ≥ 1 and x1 + · · · + xk = n } plays a crucial role. Here, lcm denotes the least common multiple. Since F depends on the irregular distribution of the prime numbers, we cannot expect to express F (n) explicitly by n. The following asymptotic tight bound on the unary NFA by DFA simulation was presented in [13,14].

28

M. Holzer and M. Kutrib

Theorem 6 (Unary NFA by DFA Simulation). Let n ≥ 1 and A be an √ n-state NFA accepting a unary language. Then eΘ( n·ln n) states are sufficient and necessary in the worst case for a DFA to accept L(A). In general, the deterministic simulation of AFAs may cost a double exponential number of states. The unary case is cheaper. Since every unary language coincides trivially with its reversal, the upper bound of the following theorem is immediately derived from Theorem 4. Interestingly, to some extend for unary languages it does not matter in general whether we simulate an AFA deterministically or nondeterministically. The tight bounds differ at most by one state. The upper bound of this claim follows since any DFA is also an NFA and NFAs are not necessarily complete. The lower bounds can be seen by considering the n single word language Ln = {a2 −1 }. For each n ≥ 1, the language Ln is accepted n by some minimal (2 + 1)-state DFA as well as by some minimal 2n -state NFA. Theorem 7 (Unary AFA by DFA and NFA Simulation). Let n ≥ 1 and A be an n-state AFA accepting a unary language. Then 2n + 1 states are sufficient and necessary in the worst case for a DFA to accept L(A). If the minimal DFA does not have a rejecting sink state, then 2n states are sufficient. Moreover, 2n states are sufficient and necessary in the worst case for an NFA to accept L(A). Theorem 5 revealed that alternation cannot help to reduce the number of states of DFAs or NFAs in all cases. The same is true for nondeterministic simulations of DFAs in general and in the unary case. However, for unary languages alternation does help. By Theorem 7 we know already that any AFA simulating an n-state DFA accepting a unary language has not less than log2 (n) − 1 states. Once more the unary single word languages Ln are witnesses that this saving can be achieved. This gives rise to the next theorem. Theorem 8 (Unary DFA by AFA Simulation). Let n ≥ 1 and A be an nstate DFA accepting a unary language. Then log2 (n) − 1 states are necessary for an AFA to accept L(A). Moreover, there exists a minimal DFA A with n states accepting a unary language such that any minimal AFA accepting L(A) has exactly log2 (n) − 1 states. Finally, we derive the always possible savings for unary NFA by AFA simulations as follows. Given some n-state NFA accepting a unary language, √ by Theorem 6 √ we obtain an equivalent DFA that has at most eΘ( n·ln n) = 2Θ( n·ln n) states. Now Theorem√4 in combination with says essentially that there is an equivalent AFA with Θ( n · ln n) states. In order to see that these savings are optimal in general, consider a unary n-state NFA such that any equivalent DFA must have √ eΘ( n·ln n) states. Since the bound of Theorem √ 6 is tight such automata exist. n · ln n) states. Otherwise there Clearly, any equivalent AFA has at least Θ( √ Θ( n·ln n) states by Theorem 7. would be an equivalent DFA with less than e Theorem 9 (Unary NFA by AFA Simulation). Let √ n ≥ 1 and A be a minimal n-state NFA accepting a unary language. Then Θ( n · ln n) states are

Descriptional and Computational Complexity of Finite Automata

29

sufficient for an AFA to accept L(A). Moreover, there exists an n-state √ NFA accepting a unary language such that any equivalent AFA requires Θ( n · ln n) states. If A is a unary n-state NFA such that any equivalent DFA √ √ has at least eΘ( n·ln n) states, then any AFA accepting L(A) has at least Θ( n · ln n) states. Concerning structural properties in [17] it is shown that negations in the Boolean functions defining an AFA can be avoided at the cost of increasing the number of states by factor of two. For the role played by the number of accepting states the following is known. While the family of languages accepted by DFAs with k accepting states is strictly contained in the family of languages accepted by DFAs with k + 1 accepting states, for k ≥ 0, it is known that for NFAs two states are always sufficient. The situation for AFAs is in contrast to the situation for DFAs but parallels the situation for NFAs. More precisely, in [17] it has been shown that for every n-state AFA A accepting a λ-free regular language one can construct an equivalent n-state AFA A without accepting state. If L(A) contains the empty word, then A has one sole accepting state that coincides with the start state.

3

Computational Complexity of Some Decision Problems for Finite Automata

We recall what is known from the computational complexity point of view on some standard problems for regular languages. The problems considered in this section are all decidable, as most problems for finite automata, and they will be grouped as mentioned in the abstract. 3.1

The Fixed and General Membership Problem

Our tour on problems for regular languages is started with the definition of the fixed and general membership problem: The former problem is device independent by definition and is commonly referred to in the literature as the fixed membership problem for regular languages: – Fix a finite automaton A. For a given word w, does the word w belong to the language L(A), i.e., is w ∈ L(A)? A natural generalization is the general membership problem, which is defined as follows: – Given a finite automaton A and a word w, i.e., a suitable coding1 A, w, does the word w belong to the language L(A), i.e., is w ∈ L(A)? 1

A coding function · maps a finite automaton A and a string w to a word A, w over a fixed alphabet Σ. We do not go into the details of ·, but assume it fulfills certain standard properties; for instance, that the coding of the input alphabet symbols as well as the coding of the states is of logarithmic length.

30

M. Holzer and M. Kutrib

Obviously, the fixed membership problem for regular languages reduces to the general membership problem for any suitable class of automata, that describes the family of regular languages. On the other hand, the complexity of the general membership problem may depend on the given language descriptor. For instance, it is easy to see that the general membership problem for DFAs is in L, and in fact, complete for L under weak reductions. The problem is NL-complete for NFAs [47], and becomes P-complete for AFAs as shown in [45]. These completeness results even hold for finite automata accepting languages over a singleton, i.e., unary languages. We summarize these results in the following theorem: Theorem 10 (General Membership). The general membership problem for DFAs is L-complete with respect to constant depth reducibilities. Moreover, the problem is NL-complete for NFAs and becomes P-complete for AFAs. The results remain valid for automata accepting unary languages. For the fixed membership problem there is much more to tell, since there is a deep and nice connection between this problem and circuit complexity theory. There exist several characterizations, in terms of formal logic, semigroup theory, and operations on languages, of the regular languages in the circuit complexity classes AC0 , ACC0 , and NC1 —see, e.g., [6,7,53]. Here AC0 (NC1 , respectively) is the class of languages accepted by uniform circuit families of constant (logarithmic, respectively) depth, polynomial size, with AND- and OR-gates of unbounded (bounded, respectively) fan-in and ACC0 is the class of languages accepted by AC0 circuits with additional MODULO-gates. Hence AC0 ⊆ ACC0 ⊆ NC1 and note that AC0 is distinct from NC1 by [3] and [18]. It is conjectured that ACC0 is a proper subset of NC1 , too. First, observe that by a divide and conquer approach it is easy to see that regular languages in general belong to NC1 . On the other hand, the NC1 lower bound (under weak reductions such as, e.g., constant depth reducibilities) was established in the landmark paper of Barrington [5], where it was shown that bounded width polynomial size programs over finite monoids recognize exactly the languages in NC1 . To this end, it was shown how to simulate the AND-, OR-, and NOT-gates of a NC1 -circuit with programs over the symmetric group S5 on five elements. Programs over monoids are a straightforward generalization of the concept of of recognizability. Here language L ⊆ Σ ∗ is recognizable if and only if there exists a finite monoid M , a morphism ϕ : Σ ∗ → M , and a subset N ⊆ M such that L = ϕ−1 (N ). In other words an input word w = a1 a2 . . . an is translated via the morphism ϕ to the word ϕ(a1 )ϕ(a2 ) . . . ϕ(an ) of monoid elements, that is evaluated in the monoid to yield a value whose N membership is tested. A program over a monoid M , for short M -program, takes an input word a1 a2 . . . an of length n and transforms it into a word σ = σ1 σ2 . . . σm , for some m, over monoid elements by querying the input positions in arbitrary order and transforming the read letter into a monoid element, which is multiplied in the monoid to yield the value of the program. More formally, an M -program for input of length n, is a sequence of instructions Pn = i1 , ϕ1  i2 , ϕ2  . . . im , ϕm , where for each j with 1 ≤ j ≤ m we have 1 ≤ ij ≤ n and ϕj : Σ → M , and an accepting subset N ⊆ M . On input w = a1 a2 . . . an , the program produces the

Descriptional and Computational Complexity of Finite Automata

31

word ϕ(w) = ϕ1 (ai1 )ϕ2 (ai2 ) . . . ϕm (aim ) of monoid elements, that is multiplied out in M and whose N membership determines whether the input is recognized or not, i.e., the word w is recognized if and only if ϕ(w) is in N . The words recognized by the M -program Pn define a language L ⊆ Σ n in the obvious way. The result in [5] reads as follows: Theorem 11 (Fixed Membership). The fixed membership problem for regular languages is NC1 -complete with respect to constant depth reducibilities. The strong algebraic background on this result has triggered further studies on M -programs over monoids satisfying certain restrictions. For instance, one of the best investigated restriction is aperiodicity. Here a monoid is aperiodic if and only if all elements x from the monoid satisfy xt = xt+1 , for some t ≥ 0. It is well known that a language L has a aperiodic syntactic monoid if and only if language L is star-free, i.e., it can be obtained from the elementary languages {a}, for a ∈ Σ, by applying Boolean operations and finitely many concatenations, where complementation is with respect to Σ ∗ . These languages are exhaustively studied in, e.g., [54] and [60]. We mention in passing that first it was shown in [63] that the aperiodicity problem (given a finite automaton with input alphabet Σ, does it accept an aperiodic or star-free language?) for DFAs is coNP-hard and belongs to PSPACE. Later this result was improved to PSPACE-completeness [11]. In fact, using some algebraic background developed in [67] on the parameterization of aperiodic and solvable monoids one can show the following result [7]. Theorem 12 (Fixed Membership). (1) The fixed membership problem for regular languages recognized by aperiodic monoids belongs to AC0 . (2) The fixed membership problem for regular languages recognized by solvable monoids belongs to ACC0 . A closer look reveals that one can obtain even more, namely a tight connection between the parameterization of AC0 in terms of circuit depth k and a parameterization of aperiodic monoids, namely Brzozowski’s dot-depth hierarchy [15,16]. Instead of using a divide-and-conquer approach as for regular languages in general, the inductive definition of dot-depth k monoids or languages allows a straightforward decomposition of language membership that gives a one-to-one correspondence between dot-depth and circuit depth. In [7] it was shown that the fixed membership problem for regular languages recognized by dot-depth k monoids is solvable in AC0 by a family of depth k circuits. 3.2

Emptiness, Universality, Equivalence, and Related Problems

In this subsection we consider non-emptiness, universality, equivalence, and some related problems such as, e.g., intersection emptiness or bounded universality or equivalence, for finite automata in more detail. Obviously, these standard problems are related to each other and we will briefly discuss their relations and moreover some consequences to the complexity of some non-trivial properties for

32

M. Holzer and M. Kutrib

problems on DFAs, NFAs, and AFAs. The non-emptiness problem for NFAs is defined as follows: – Given a nondeterministic finite automaton A, is L(A) = ∅? Moreover, the universality problem for NFAs is: – Given a nondeterministic finite automaton A with input alphabet Σ, is the language L(A) universal, i.e., L(A) = Σ ∗ ? The equivalence problem for NFAs is defined for two devices as: – Given two nondeterministic finite automata A1 and A2 , is L(A1 ) = L(A2 )? This notation naturally generalizes to other types of finite automata. Intuitively, the universality problem can be much harder than the corresponding emptiness problem, which may also be true for the equivalence problem and the universality problem. For instance, it is easy to see that emptiness reduces to non-universality if the automata are logspace effectively closed under arbitrary homomorphism and concatenation with regular languages. Here a class of automata C is logspace effectively closed under arbitrary homomorphism, if for any automaton A from C with n states and any homomorphism h, one can construct within deterministic logspace an automaton B from C that accepts language h(L(A)). This implies that the number of states of B is bounded by some polynomial pR (n). Similarly logspace effective closure under concatenation with regular languages is defined. More general conditions for logspace many-one reductions of universality or emptiness to equivalence, where one of the languages is a fixed language, were studied in detail in a series of papers by Hunt III and co-authors [37,38,39]. Now let us come to the complexity of the emptiness problem for finite automata. In general, if automata are logspace effectively closed under intersection with regular sets, then the general membership logspace many reduces to the non-emptiness problem for the same type of automata, because w ∈ L(A) if and only if L(A) ∩ {w} = ∅. Conversely, non-emptiness logspace many-one reduces to general membership, if the automata are logspace effectively closed under homomorphism, since L(A) = ∅ if and only if h(L(A)) = ∅ if and only if λ ∈ h(L(A)), where h(a) = λ, for a ∈ Σ. In [47] the following result on the non-emptiness problem for NFAs was shown, which even holds for DFAs—since nondeterministic space complexity classes are closed under complementation [43,66] the result also holds for the emptiness problem. Moreover, non-emptiness for AFAs was considered in [45] and [28]. Theorem 13 (Non-Emptiness). The non-emptiness problem for NFAs and DFAs is NL-complete, and it is PSPACE-complete for AFAs. The results remain valid for automata accepting unary languages. A natural variant of non-emptiness is intersection non-emptiness. This is the  problem to decide whether 1≤i≤n L(Ai ) = ∅, for given finite automata A1 , A2 , . . . , An ? If the number of automata in the input instance is bounded by

Descriptional and Computational Complexity of Finite Automata

33

some function g(n), then this problem is referred to as the g(n)-bounded intersection non-emptiness problem. For easier readability we abbreviate the former  g(n) problem by ∅ = C and the latter one by ∅ = C, where C is from {DFA, NFA, AFA}. Trivially, non-emptiness logspace many-one reduces to intersection non-emptiness, even to k-bounded intersection non-emptiness for constantk. The results on these problems readas follows: In [48] it was shown that ∅ = DFA is PSPACE-complete. Since  ∅ = AFAcan be decided within nondeterministic polynomial space, ∅ = NFA and ∅ = AFA are PSPACE-complete, too. Recently it was shown in [4] that the infinite cardinality intersection problem, i.e., given  automata A1 , A2 , . . . , An from C, does there exist infinitely many words in 1≤i≤n L(Ai ) is also PSPACE-complete, for DFAs. Further PSPACEcomplete problems on NFAs based on pattern and power acceptance were identified in [4]. For DFAs and NFAs these intractable intersection emptiness problems become feasible, if the number of finite automata is bounded by some constant k, but remains intractable for AFAs. More kthe k-bounded interseck precisely, both DFA and ∅ = NFA are NL-complete, tion non-emptiness problems ∅ = k for each k with k ≥ 1, by [19], and ∅ = AFA remains obviously PSPACEcomplete. Moreover, for the bounded intersection non-emptiness problem in geng(n) g(n) eral it was shown in [49] that both ∅ = DFA and ∅ = NFA are logk−1 n complete for NSPACE(g(n) · log n). In particular, both ∅ = DFA and logk−1 n k ∅ = NFA are NSPACE(log n)-complete, for k ≥ 1. Observe, that these were the first natural complete problems for this complexity class. Finally, what can be said about the (bounded) intersection non-emptiness problem for the automata under consideration, when restricted to unary inputalphabet? As a  consequence of [19] and [65] both ∅ = Tally-DFA and ∅ = Tally-NFA are NP-complete, while ∅ = Tally-AFA again remains PSPACE-complete [28]—the abbreviation of the problem instance are self-explaining. The latter result also holds for the bounded variant, even for constant k. In [49] it is briefly mentioned k k Tally-DFA is L- and ∅ = Tally-NFA is NL-complete. On the other that ∅ = hand, completeness results for the bounded intersection non-emptiness problem are not known for unary languages, as in the general case. Nevertheless, involved upper and lower bounds by simultaneously bounded complexity classes (time, space, and number of nondeterministic steps) were shown in [49]. Another problem closely connected to non-emptiness is the so-called short word problem, which was investigated in [49], too. The main idea underlying short words is that in general the shortest word accepted of an NFA can be of exponential length in the coding of this automaton. Thus, the natural question arises whether the automaton accepts words which are “short” in some sense. Regarding words of linear length as short, we can define the short word problem as follows: Given a finite automaton A, is there a word w of length less or equal than the coding of A, such that w ∈ L(A)? We abbreviate this problem by ∅ = Clin and ∅ = Tally-Clin when the automata accept unary languages, where C ∈ {DFA, NFA, AFA}. Using standard methods one sees

34

M. Holzer and M. Kutrib

that ∅ = DFAlin and ∅ = NFAlin are NL-complete, while ∅ = Tally-DFAlin is L-complete and ∅ = Tally-NFAlin is NL-complete. For AFAs it was shown in [28] that ∅ = AFAlin is NP- and ∅ = Tally-AFAlin is P-complete. Considering the combination of the (bounded) intersection non-emptiness problem with the short word restriction leads to more interesting results. We refer to g(n) g(n) these problems as ∅ = Clin and ∅ = Tally-Clin , respectively. The g(n) g(n) problems ∅ = DFAlin and ∅ = NFAlin are complete for simultaneously time and space bounded classes between NTISP(pol n, log n) = NL and NTISP(pol n, pol n) = NP, namely for NTISP(pol n, g(n) · log n)—see [49]. For g(n) = logk n these classes are the nondeterministic counterparts of the SCk -hierarchy. The restriction of these problems with respect to DFAs (NFAs, respectively) to short words, always leads to L-complete (NL-complete, respectively) sets, regardless of the function g(n). The corresponding problems for   AFAs, namely ∅ = g(n) AFAlin and ∅ = g(n) Tally-AFAlin are P-complete, also regardless of g(n). Now let us consider the next standard problem, the universality problem. As previously mentioned, emptiness and universality are closely related to each other by the complementation operation. The universality problem for DFAs was shown to be NL-complete [12]. For NFAs and AFAs, respectively, the problem under consideration was investigated in [1,57] and [28], respectively, in more detail. For the results on automata accepting unary languages we refer to [65] and [28]. We summarize these results in the following theorem. Theorem 14 (Universality). The universality problem for DFAs is NL-complete and for NFAs and AFAs it is PSPACE-complete. For automata accepting unary languages, the universality problem is NL-complete for DFAs, coNP-complete for NFAs, and PSPACE-complete for AFAs. Next we consider two variants of universality. The first one is the union universality problem, that is to decide for given automata A1 , A2 , . . . , An , whether  ∗ 1≤i≤n L(Ai ) = Σ ? Trivially, universality logspace many-one reduces to the union universality problem for any class of automata. For DFAs this problem is readily seen to be PSPACE-complete by a reduction from the intersection emptiness problem for DFAs, which was discussed in detail earlier. For NFAs and AFAs the union universality problem is PSPACE-complete, too, since it is already PSPACE-hard for a single automaton, and containment can easily be seen since NFAs and AFAs are logspace effective closed under union. Thus, further variants of this problem, comparable to variants of the intersection emptiness problem, are not worth studying. Another, not to well-known generalization of the universality problem is the bounded universality problem first studied in [12]. The bounded universality problem is the problem of deciding for a given finite automaton A and a unary integer n, whether L(A) ∩ Σ ≤n = Σ ≤n ? The bounded non-universality problem is defined accordingly. In [12] it was shown that the bounded universality problem for NFAs is coNP-complete, while it is NL-complete for DFAs. Thus, the complexity of non-bounded universality is significantly lower than that of the equivalence problem, which is discussed below.

Descriptional and Computational Complexity of Finite Automata

35

Regarding the problem of computing the lexically first witness string that proves bounded non-universality for NFAs, an ΔP2 upper bound, and NP- and coNPhardness lower bounds were shown in [12]. Computing any witness string, thus dropping the lexically first criterion, leads to a problem that is computational equivalent to the bounded non-universality problem and, thus, is an NP-complete problem for NFAs. For AFAs the bounded universality is seen to be coNPcomplete. The last standard problem we are interested in, is the equivalence problem. Besides the emptiness problem, the equivalence problem is certainly one of the most important decision problems that has been investigated extensively in the literature. That equivalence is harder than emptiness is (partially) true for DFAs and NFAs, because equivalence is NL-complete for deterministic [12] and PSPACEcomplete for NFAs. However, in case of AFAs equivalence remains as hard as emptiness as shown in [45]. Automata on unary input alphabet were investigated in [28,65]. As the reader may notice, universality and equivalence are computational equivalent with respect to logspace many-one reductions for the finite automata types under consideration. Theorem 15 (Equivalence). The equivalence problem for DFAs is NL-complete and for NFAs and AFAs it is PSPACE-complete. For automata accepting unary languages, the universality problem is NL-complete for DFAs, coNP-complete for NFAs, and PSPACE-complete for AFAs. Most of the presented results on emptiness, universality, and equivalence date back to the pioneering papers [57,64,65] and [27,36,37,38,39,62], where mostly problems on regular-like expressions were investigated. Obviously, a lower bound on the computational complexity of a problem for ordinary regular expressions implies the same lower bound for NFAs, since any regular expression of size n can be converted into an equivalent (n + 1)-state NFA [42]. Most of these results on regular expressions are summarized in [20]—e.g., one can read the following entry, literally taken from [20], on inequivalence for regular expressions: “[The inequivalence for regular expressions r1 and r2 , i.e., deciding whether L(r1 ) = L(r2 ), is . . . ] PSPACE-complete, even if |Σ| = 2 and L(r2 ) = Σ ∗ . In fact, PSPACE-complete if r2 is any fixed expression representing an “unbounded” language [39]. NP-complete for fixed r2 representing any infinite “bounded” language, but solvable in polynomial time for fixed r2 representing any finite language. The general problem remains PSPACE-complete if r1 and r2 both have “star-height” k for fixed k ≥ 1 [39], but is NP-complete for k = 0 (“star-free”) [34,65]. Also NP-complete if one of both of r1 and r2 represent bounded languages (a property that can be checked in polynomial time) [39] or if |Σ| = 1 [65]. For related results and intractable generalizations, see cited references, [35], and [38].” Here a language L is bounded if and only if there exist words w1 , w2 , . . . , wk , for some k, such that L ⊆ w1∗ w2∗ . . . wk∗ . In [41] it was shown that boundedness

36

M. Holzer and M. Kutrib

is a necessary and sufficient condition for context-free languages to be sparse. A language L ⊆ Σ ∗ is sparse, if there exists a polynomial p such that for all n we have |L ∩ Σ ≤n | ≤ p(n), where Σ ≤n is the set of all words over Σ of length at most n. While boundedness for languages specified by regular expressions is easily shown to be solvable in polynomial time via an inductive proof [39], it is not that clear, whether this also holds for NFAs. Here the equivalence of boundedness and sparseness for context-free languages comes into play. The sparseness problem, i.e., given an automaton A, is L(A) sparse?, was shown to be NL-complete for both DFAs and NFAs [40], and for AFAs it is PSPACE-complete. For automata accepting unary languages the problem under consideration is trivial. Hence, the boundedness problem for NFAs is efficiently solvable. Next we summarize some results on some problems related to universality and equivalence, namely the segment equivalence and the closeness problem: (1) The segment equivalence problem is defined as follows: Given two automata A1 and A2 and n, is L(A1 ) ∩ Σ ≤n = L(A2 ) ∩ Σ ≤n ? If n is coded in binary, it is called the binary-encoded segment equivalence problem. Segment and binary-encoded segment equivalence were studied in [40]. There it was shown that segment equivalence for DFAs is NL-complete, whereas for NFAs the problem becomes coNPcomplete. As in case of ordinary equivalence one can show that the complexity of segment equivalence for AFAs is the same as for NFAs, hence coNP-complete, if the input alphabet contains at least two letters. For automata accepting unary languages it is easy to see that the segment equivalence problem is L-complete for DFAs, NL-complete for NFAs, and P-complete for AFAs. Moreover, for the binary-encoded segment equivalence problem it was shown that both NFAs and AFAs induce a PSPACE-complete problem [40]. (2) The closeness problem measures the similarity of languages in terms of the density of their symmetric difference, i.e., two languages L1 and L2 are close if and only if (L1 \ L2 ) ∪ (L2 \ L1 ) is sparse. Thus, the closeness problem is to decide whether for given two automata A1 and A2 , the symmetric difference of L(A1 ) and L(A2 ) is sparse? In [40] it was shown that the closeness problem for DFAs is NL-complete and for NFAs it is PSPACE-complete. Moreover, PSPACE-completeness also holds for the closeness problem for AFAs. Note, that the closeness problem for automata accepting unary languages is trivial. Along the lines of development in computational complexity theory, authors began to study functional problems and classes, see, e.g., [2]. One of the most easiest functional problems for finite state devices is census. Here for a given finite automaton A and 1n , one asks how many words up to length n are accepted by A? Other well known functional problems are census of the complement, ranking, maximal word, and maximal relative word—for a precise definition of these problems we refer to [2]. For DFAs and NFAs it was shown in [2] that most of these problems are complete for logarithmic space bounded counting classes like, e.g., #L, spanL, or optL, while for AFAs these problems turn out to be complete for their polynomially time bounded counterparts #P or optP [28]. We have seen that most problems for NFAs and AFAs are intractable, while some problem for DFAs are effectively solvable. In the remainder of this

Descriptional and Computational Complexity of Finite Automata

37

subsection we consider two results of Hunt III and co-authors [27,38], which show that the above mentioned behavior on the computational complexity of DFA and NFA based problems is not accidental. It thus explains in part, why most problems for NFAs and AFAs are intractable. We feel that these nice results demand more attention, therefore we present it here. Theorem 16 (Hardness for DFAs and NFAs Problems). Let Σ be an ∗ alphabet with |Σ| ≥ 2 and P : 2Σ → {0, 1} be any non-trivial predicate on the regular languages. Assume that the set Pleft of all languages δx (L), where L is a regular language, P (L) is true, and x ∈ Σ ∗ , is not equal to the family of all regular languages—here δx (L) = { y ∈ Σ ∗ | xy ∈ L } refers to the left quotient of L with respect to the word x from Σ ∗ . Then the P -problem for NFAs, that is, to determine whether for a given nondeterministic finite automaton A the predicate P on L(A) is true, is PSPACE-hard, assuming P (Σ ∗ ) to be true. Moreover, the corresponding P -problem for DFAs is at least NL-hard. Finally, we summarize some results on the operation problem from the computational complexity perspective. For a survey on the descriptional complexity of the operation problem for DFAs and NFAs we refer to [68] and [29,30]. Let ◦ be a fixed operation on languages that preserves regularity. Then the ◦operation problem is defined as follows: Given finite automata A1 , A2 , and A3 , is L(A1 ) ◦ L(A2 ) = L(A3 )? Obviously, this problem generalizes to unary language operations. It turned out that both the concatenation operation problem and the Kleene star operation for DFAs are PSPACE-complete [46]. A converse problem to the ◦-operation problem is the minimum ◦-problem. That is, given a finite automaton A and an integer k, are there finite automata A1 and A2 of the same type with |A1 | + |A2 | ≤ k such that L(A1 ) ◦ L(A2 ) = L(A)? For DFAs this problem is NP-complete for union and intersection, and PSPACE-complete for concatenation and Kleene star. Interestingly, the minimum reverse-operation problem is shown to be solvable in polynomial time if the integer k is given in unary, although DFAs are not logspace effective closed under reversal. 3.3

Minimization of Finite Automata

The study of the minimization problem for finite automata dates back to the early beginnings of automata theory. Here we focus mainly on some recent developments related to this fundamental problem—for further reading we refer to [46] and references therein. The minimization problem is also of practical relevance, because regular languages are used in many applications, and one may like to represent the languages succinctly. The decision version of the minimization problem, for short the NFA-to-NFA minimization problem, is defined as follows: – Given a nondeterministic finite automaton A and a natural number k in binary, that is, an encoding A, k, is there an equivalent k-state nondeterministic finite automaton? This notation naturally generalizes to other types of finite automata, for example, the DFA-to-NFA minimization problem. It is well known that for a given

38

M. Holzer and M. Kutrib

n-state DFA one can efficiently compute an equivalent minimal automaton in O(n log n) time [32]. More precisely, the DFA-to-DFA minimization problem is complete for NL, even for DFAs without inaccessible states [12]. This is contrary to the nondeterministic case since the NFAs minimization problem is known to be computationally hard [46], which is also true for AFAs. The PSPACE-hardness result for NFAs was shown by a reduction from the union universality problem to the NFA-to-NFA minimization problem. For some further problems related to minimization we refer also to [24]. Theorem 17 (Minimization). The DFA-to-DFA minimization problem is NL-complete, while the NFA-to-NFA minimization problem is PSPACE-complete, even if the input is given as a deterministic finite automaton. The AFA-to-AFA minimization problem is PSPACE-complete, too. In order to better understand the very nature of nondeterminism one may ask for minimization problems for restricted types of finite automata. Already in [46] it was shown that for the restricted class of unambiguous finite automata (UFA) some minimization problems remain intractable. To be more precise, the UFAto-UFA and the DFA-to-UFA minimization problems are NP-complete. We mention in passing that in [12] necessary and sufficient conditions were provided to distinguish between exponential, polynomial, bounded, and k-bounded ambiguity, and it was shown that these ambiguity problems, i.e., determining whether the degree of ambiguity of a given NFA is exponential, polynomial, bounded, k-bounded, where k is a fixed integer, or unambiguous are all NL-complete. Later in [52] it was shown that the minimization of finite automata equipped with a very small amount of nondeterminism is already computationally hard. To this end, a reduction from the NP-complete minimal inferred DFA problem [21,46] to the the minimization problems for multiple initial state deterministic finite automata with a fixed number of initial states (MDFA) as well as for nondeterministic finite automata with fixed finite branching has been shown. Prior to this, the MDFA-to-DFA minimization problem in general was proven to be PSPACE-complete in [31]. Here the minimal inferred DFA problem [21] is defined as follows: Given a finite alphabet Σ, two finite subsets S, T ⊆ Σ ∗ , and an integer k, is there an k-state DFA that accepts a language L such that S ⊆ L and T ⊆ Σ ∗ \ L? Such an automaton can be seen as a consistent “implementation” of the sets S and T . Recently, the picture was completed in [8] by getting much closer to the tractability frontier for nondeterministic finite automata minimization. There a class of NFAs is identified, the so called δ-nondeterministic finite automata (δNFA), such that the minimization problem for any class of finite automata that contains δNFAs is NP-hard, even if the input is given as a DFA. Here the class of δNFAs contains all NFAs with the following properties: (i) The automaton is unambiguous, (ii) the maximal product of the degrees of nondeterminism over the states in a possible computation is at most 2, and (iii) there is at most on state q and a letter a such that the degree of nondeterminism of q and a is 2. It is worth mentioning that for every n-state δNFA there is an equivalent DFA with at most O(n2 ) states.

Descriptional and Computational Complexity of Finite Automata

39

The situation for the minimization problem in general is, in fact, even worse. Recent √ work [23] shows that the DFA-to-NFA problem cannot be approximated within n/polylogn for state minimization and n/polylogn for transition minimization, provided some cryptographic assumption holds. Moreover, the NFAto-NFA minimization problem was classified to be inapproximable within o(n), unless P = PSPACE, if the input is given as an NFA with n states [23]. That is, no polynomial-time algorithm can determine an approximate solution of size o(n) times the optimum size. Even the DFA-to-NFA minimization problem remains inapproximable within a factor of at least n1/3− , for all > 0, unless P = NP [26], for alphabets of size O(n), and not approximable within n1/5− for a binary alphabet, for all > 0. Under the same assumption, it was shown that the transition minimization problem for binary input alphabets is not approximable within n1/5− , for all > 0. The results in [26] proved approximation hardness results under weaker (and more familiar) assumptions than [23]. Further results on the approximability of the minimization problem when the input is specified as regular expression or a truth table can be found in [23,26]. The unary NFA-to-NFA minimization problem is coNP-hard [65], and similarly as in the case of finite languages contained in Σ2P . The number of states of a minimal NFA equivalent to a given unary cyclic DFA cannot be computed in polynomial time, unless NP ⊆ DTIME(nO(log n) ) [44]. Note that in the latter case the corresponding decision version belongs to NP. Inapproximability results for the problem in question have been found during the last years, if the input is √ n a unary NFA: The problem cannot be approximated within ln n [22], and if one requires in addition the explicit construction of an equivalent NFA, the inapproximability ratio can be raised to n1− , for every > 0, unless P = NP [23]. On the other hand, if a unary cyclic DFA with n states is given, the nondeterministic state complexity of the considered language can be approximated within a factor of O(log n). The picture on the unary NFA-to-NFA minimization problem was completed in [25]. Some of the aforementioned (in)approximability results, which only hold for the cyclic case, generalize to unary languages in general. In particular, it was shown that for a given n-state NFA accepting a unary language, it is impossible to approximate the nondeterministic state complexity within o(n), unless P = NP. Observe that this bound is tight. In contrast, it is proven that the NFA-to-NFA minimization problem can be constructively approximated within √ O( n), where n is the number of states of the given DFA. Here by constructively approximated we mean that we can build the nondeterministic finite automaton, instead of only approximately determining the number of states needed. This solves an open problem stated in [46] on the complexity of converting a DFA to an approximately optimal NFA in the case of unary languages.

References 1. Aho, A.V., Hopcroft, J.E., Ullman, J.D.: The Design and Analysis of Computer Algorithms. Addision-Wesley, Reading (1974) ´ 2. Alvarez, C., Jenner, B.: A very hard log-space counting class. Theoret. Comput. Sci. 107, 3–30 (1993)

40

M. Holzer and M. Kutrib

3. Ajtai, M.: Σ11 formulae on finite structures. Ann. Pure. Appl. Logic 24, 1–48 (1983) 4. Anderson, T., Rampersad, N., Santean, N., Shallit, J., Loftus, J.: Detecting palindroms, patterns and borders in regular languages (2008) arXiv:0711.3183v2 [cs.CC] 5. Barrington, D.A.: Bounded-width polynomial-size branching programs recognize exactly those languages in NC1 . J. Comput. System Sci. 38, 150–164 (1989) 6. Barrington, D.A.M., Immerman, N., Straubing, H.: On uniformity within NC1 . J. Comput. System Sci. 41, 274–306 (1990) 7. Barrington, D.M., Th´erien, D.: Finite monoids and the fine structure of NC1 . J. ACM 35, 941–952 (1988) 8. Bj¨ orklund, H., Martens, W.: The tractability frontier for NFA minimization. In: Aceto, L., Damg˚ ard, I., Goldberg, L.A., Halld´ orsson, M.M., Ing´ olfsd´ ottir, A., Walukiewicz, I. (eds.) ICALP 2008, Part II. LNCS, vol. 5126, pp. 27–38. Springer, Heidelberg (2008) 9. Brzozowski, J.A., Leiss, E.L.: On equations for regular languages, finite automata, and sequential networks. Theoret. Comput. Sci. 10, 19–35 (1980) 10. Chandra, A., Kozen, D., Stockmeyer, L.: Alternation. J. ACM 21, 114–133 (1981) 11. Cho, S., Huynh, D.T.: Finite-automaton aperiodicity is PSPACE-complete. Theoret. Comput. Sci. 88, 99–116 (1991) 12. Cho, S., Huynh, D.T.: The parallel complexity of finite-state automata problems. Inform. Comput. 97, 1–22 (1992) 13. Chrobak, M.: Finite automata and unary languages. Theoret. Comput. Sci. 47, 149–158 (1986) 14. Chrobak, M.: Errata to finite automata and unary languages. Theoret. Comput. Sci. 302, 497–498 (2003) 15. Cohen, R.S., Brzozowski, J.A.: Dot-depth of star-free events. J. Comput. System Sci. 5, 1–16 (1971) 16. Eilenberg, S.: Automata, Languages, and Machines (Volume B), vol. 59-B. Academic Press, London (1976) 17. Fellah, A., J¨ urgensen, H., Yu, S.: Constructions for alternating finite automata. Internat. J. Comput. Math. 35, 117–132 (1990) 18. Furst, M.L., Saxe, J.B., Sipser, M.: Parity, circuits, and the polynomial-time hierarchy. Math. Systems Theory 17, 13–27 (1984) 19. Galil, Z.: Hierarchies of complete problems. Acta Inform. 6, 77–88 (1976) 20. Garey, M.R., Johnson, D.S.: Computers and Intractability, A Guide to the Theory of NP-Completeness. Freeman, New York (1979) 21. Gold, E.M.: Complexity of automaton identification from given data. Inform. Control 37, 302–320 (1978) 22. Gramlich, G.: Probabilistic and nondeterministic unary automata. In: Rovan, B., Vojt´ aˇs, P. (eds.) MFCS 2003. LNCS, vol. 2747, pp. 460–469. Springer, Heidelberg (2003) 23. Gramlich, G., Schnitger, G.: Minimizing nFA’s and regular expressions. In: Diekert, V., Durand, B. (eds.) STACS 2005. LNCS, vol. 3404, pp. 399–411. Springer, Heidelberg (2005) 24. Gruber, H., Holzer, M.: Finding lower bounds for nondeterministic state complexity is hard. In: H. Ibarra, O., Dang, Z. (eds.) DLT 2006. LNCS, vol. 4036, pp. 363–374. Springer, Heidelberg (2006) 25. Gruber, H., Holzer, M.: Computational complexity of NFA minimization for finite and unary languages. In: Language and Automata Theory and Applications (LATA 2007), pp. 261–272. Technical Report 35/07, Universitat Rovira i Virgili, Tarragona (2007)

Descriptional and Computational Complexity of Finite Automata

41

26. Gruber, H., Holzer, M.: Inapproximability of nondeterministic state and transition complexity assuming P = NP. In: Harju, T., Karhum¨ aki, J., Lepist¨ o, A. (eds.) DLT 2007. LNCS, vol. 4588, pp. 205–216. Springer, Heidelberg (2007) 27. Hartmanis, J., Hunt III, H.B.: The LBA problem and its importance in the theory of computing. In: SIAM AMS. Complexity of Computing, vol. 7, pp. 1–26 (1974) 28. Holzer, M.: On emptiness and counting for alternating finite automata. In: Developments in Language Theory II; at the Crossroads of Mathematics, Computer Science and Biology, pp. 88–97. World Scientific, Singapore (1996) 29. Holzer, M., Kutrib, M.: State complexity of basic operations on nondeterministic finite automata. In: Champarnaud, J.-M., Maurel, D. (eds.) CIAA 2002. LNCS, vol. 2608, pp. 148–157. Springer, Heidelberg (2003) 30. Holzer, M., Kutrib, M.: Nondeterministic finite automata—recent results on the descriptional and computational complexity. In: Ibarra, O., Ravikumar, B. (eds.) CIAA 2008. LNCS, vol. 5148, pp. 1–16. Springer, Heidelberg (2008) 31. Holzer, M., Salomaa, K., Yu, S.: On the state complexity of k-entry deterministic finite automata. J. Autom., Lang. Comb. 6, 453–466 (2001) 32. Hopcroft, J.: An n log n algorithm for minimizing the state in a finite automaton. In: The Theory of Machines and Computations, pp. 189–196. Academic Press, London (1971) 33. Hopcroft, J.E., Ullman, J.D.: Introduction to Automata Theory, Languages and Computation. Addison-Wesley, Reading (1979) 34. Hunt III, H.B.: On the time and tape complexity of languages. Ph.D. thesis, Cornell University, Ithaca, New York, USA (1973) 35. Hunt III, H.B.: On the time and tape complexity of languages I. In: Symposium on Theory of Computing (STOC 1973), pp. 10–19. ACM Press, New York (1973) 36. Hunt III, H.B.: Observations on the complexity of regular expressions problems. J. Comput. System Sci. 19, 222–236 (1979) 37. Hunt III, H.B., Rosenkrantz, D.J.: On equivalence and contaiment problems for formal languages. J. ACM 24, 387–396 (1977) 38. Hunt III, H.B., Rosenkrantz, D.J.: Computational parallels between the regular and context-free languages. SIAM J. Comput. 7, 99–114 (1978) 39. Hunt III, H.B., Rosenkrantz, D.J., Szymanski, T.G.: On the equivalence, containment, and covering problems for the regular and context-free languages. J. Comput. System Sci. 12, 222–268 (1976) 40. Huynh, D.T.: Complexity of closeness, sparseness and segment equivalence for context-free and regular languages. In: Informatik, Festschrift zum 60, Geburtstag von G¨ unter Hotz, Teubner, pp. 235–251 (1992) 41. Ibarra, O.H., Ravikumar, B.: On sparseness, ambiguity and other decision problems for acceptors and transducers. In: Monien, B., Vidal-Naquet, G. (eds.) STACS 1986. LNCS, vol. 210, pp. 171–179. Springer, Heidelberg (1985) 42. Ilie, L., Yu, S.: Follow automata. Inform. Comput. 186, 140–162 (2003) 43. Immerman, N.: Nondeterministic space is closed under complementation. SIAM J. Comput. 17, 935–938 (1988) 44. Jiang, T., McDowell, E., Ravikumar, B.: The structure and complexity of minimal NFAs over a unary alphabet. Internat. J. Found. Comput. Sci. 2, 163–182 (1991) 45. Jiang, T., Ravikumar, B.: A note on the space complexity of some decision problems for finite automata. Inform. Process. Lett. 40, 25–31 (1991) 46. Jiang, T., Ravikumar, B.: Minimal NFA problems are hard. SIAM J. Comput. 22, 1117–1141 (1993) 47. Jones, N.: Space-bounded reducibility among combinatorial problems. J. Comput. System Sci. 11, 68–85 (1975)

42

M. Holzer and M. Kutrib

48. Kozen, D.: Lower bounds for natural proof systems. In: Foundations of Computer Science (FOCS 1977), pp. 254–266. IEEE Society Press, Los Alamitos (1977) 49. Lange, K.J., Rossmanith, P.: The emptiness problem for intersections of regular languages. In: Havel, I.M., Koubek, V. (eds.) MFCS 1992. LNCS, vol. 629, pp. 346–354. Springer, Heidelberg (1992) 50. Leiss, E.: Succinct representation of regular languages by Boolean automata. Theoret. Comput. Sci. 13, 323–330 (1981) 51. Leiss, E.: Succinct representation of regular languages by Boolean automata. II. Theoret. Comput. Sci. 38, 133–136 (1985) 52. Malcher, A.: Minimizing finite automata is computationally hard. Theoret. Comput. Sci. 327, 375–390 (2004) 53. McKenzie, P., P´eladeau, P., Th´erien, D.: NC1 : The automata-theoretical viewpoint. Comput. Compl. 1, 330–359 (1991) 54. McNaughton, R., Papert, S.: Counter-free automata. Research monographs, vol. 65. MIT Press, Cambridge (1971) 55. Mereghetti, C., Pighizzini, G.: Optimal simulations between unary automata. SIAM J. Comput. 30, 1976–1992 (2001) 56. Meyer, A.R., Fischer, M.J.: Economy of description by automata, grammars, and formal systems. In: IEEE Symposium on Switching and Automata Theory (SWAT 1971), pp. 188–191. IEEE Society Press, Los Alamitos (1971) 57. Meyer, A.R., Stockmeyer, L.J.: The equivalence problem for regular expressions with squaring requires exponential time. In: Symposium on Switching and Automata Theory (SWAT 1972), pp. 125–129. IEEE Society Press, Los Alamitos (1972) 58. Moore, F.R.: On the bounds for state-set size in the proofs of equivalence between deterministic, nondeterministic, and two-way finite automata. IEEE Trans. Comput. 20, 1211–1214 (1971) 59. Rabin, M.O., Scott, D.: Finite automata and their decision problems. IBM J. Res. Dev. 3, 114–125 (1959) 60. Sch¨ utzenberger, M.P.: On finite monoids having only trivial subgroups. Inform. Control 8, 190–194 (1965) 61. Sipser, M.: Lower bounds on the size of sweeping automata. J. Comput. System Sci. 21, 195–202 (1980) 62. Stearns, R.E., Hunt, H.B.: On the equivalence and containment problems for unambiguous regular expressions, regular grammars, and finite automata. SIAM J. Comput. 14, 598–611 (1985) 63. Stern, J.: Complexity of some problems from the theory of automata. Inform. Control 66, 163–176 (1985) 64. Stockmeyer, L.J.: The Complexity of Decision Problems in Automata Theory and Logic. Ph.D. thesis, MIT, Cambridge, Massasuchets, USA (1974) 65. Stockmeyer, L.J., Meyer, A.R.: Word problems requiring exponential time. In: Symposium on Theory of Computing (STOC 1973), pp. 1–9. ACM Press, New York (1973) 66. Szelepcs´enyi, R.: The method of forced enumeration for nondeterministic automata. Acta Inform. 26, 279–284 (1988) 67. Th´erien, D.: Classification of finite monoids: the language approach. Theoret. Comput. Sci. 14, 195–208 (1981) 68. Yu, S.: State complexity of regular languages. J. Autom., Lang. Comb. 6, 221–234 (2001)

Hypothesis Spaces for Learning Sanjay Jain Department of Computer Science, National University of Singapore, Singapore 117590, Republic of Singapore [email protected]

Abstract. In this paper we survey some results in inductive inference showing how learnability of a class of languages may depend on hypothesis space chosen. We also discuss results which consider how learnability is effected if one requires learning with respect to every suitable hypothesis space. Additionally, optimal hypothesis spaces, using which every learnable class is learnable, is considered.

1

Introduction

A learning scenario can be described as follows. Consider a learner (a computable device) receiving data, one piece at a time, about some target concept (which is from a class of possible concepts). As the learner is receiving its data, it conjectures a possible description of the target concept. One may consider the learner to be successful if its sequence of conjectures converges to a correct description of the target concept. In this paper we will be mostly concerned with language learning. A language is some recursively enumerable (r.e.) subset of a universal set. By appropriate coding, one may take the universal set to be the set of natural numbers, N = {0, 1, 2, . . .}. For learning languages, the data provided to the learner is usually the set of positive examples of the language, one element at a time, where all the elements are eventually provided and no non-elements of the language are provided. This form of data presentation is called a text for the language. This model originates from the observation that in many natural situations, such as language learning by children or in astronomy, one gets essentially only positive data. A related model of data presentation, called informant, is when the learner is presented with all elements of the universal set, appropriately classified as positive or negative with respect to the target language. The conjectures of the learner take the form of a grammar from some hypothesis space (we always assume that hypothesis space is an r.e. indexing of r.e. languages; in some cases we additionally assume that membership question for hypothesis i is decidable effectively in i — in these cases the hypothesis space is an indexed family of recursive languages). A criterion of success, as considered above, is for the sequence of grammars to converge to a grammar for the target language. This is essentially the criterion of learning first considered by Gold [16], and commonly called explanatory learning (abbreviated TxtEx-learning, for explanatory learning from 

Supported in part by NUS grant number R252-000-308-112.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 43–58, 2009. c Springer-Verlag Berlin Heidelberg 2009 

44

S. Jain

text, and InfEx-learning, for explanatory learning from informant). Note that the learner is expected to succeed on all possible order of presentation of the elements of the target language. Learning of one language is usually not much interesting as some learner, which always outputs the grammar for this language, will succeed. What is more interesting is whether some learner can learn all the languages from a class L of languages. We now formally define the criterion described above. A sequence is a mapping from N or an initial segment of N to N ∪ {#}. An information sequence is a mapping from N or an initial segment of N to (N × {0, 1}) ∪ {#}. Content of a (information) sequence σ, denoted content(σ), is range(σ) − {#} (# is considered as a pause symbol, representing no data. This is useful when one considers presenting data for empty language). Let SEQ denote the set of all finite sequences. Let SEG denote the set of all finite information sequences σ such that {(x, y), (x, z)} ⊆ content(σ) implies y = z (we only care about consistent information sequences). An infinite sequence T is a text for a language L iff content(T ) = L. We let T (with or without subscripts/superscripts) range over texts. An infinite information sequence I is an informant for a language L iff content(I) = {(x, χL (x)) : x ∈ N}, where χL is the characteristic function for the language L. We let I (with or without subscripts/superscripts) range over informants. T [n] (respectively I[n]) denotes the finite sequence consisting of the first n elements in the sequence T (respectively I). A learning machine (also called a learner) is an algorithmic mapping (possibly partial) from SEQ or SEG (depending on whether one is considering learning from texts or informants) to N ∪ {?}. A learner M converges on a text T to i (denoted M (T )↓ = i) iff for all but finitely many n, M (T [n]) = i. Convergence on information sequence I is defined similarly. Here one interprets the output of the learner as an index for some language in a hypothesis space. Thus output i would represent the conjecture Hi , where H0 , H1 , . . . is the hypothesis space used by the learner. The output of ? denotes that the learner is not making a formal conjecture (this is useful when one considers some special cases, such as bounding the number of mind changes made by the learner). Definition 1. [16] Fix a hypothesis space H = H0 , H1 , . . .. (a) A learner M TxtExH -identifies a language L (written: L ∈ TxtExH (M )) iff for all texts T for L, (i) M (T [n]) is defined for all n, and (ii) there exists an i such that M (T )↓ = i and Hi = L. (b) A learner M TxtExH -identifies a class L of languages (written: L ⊆ TxtExH (M )) iff it TxtExH -identifies all languages in the class L. (c) TxtExH = {L : (∃M )[M TxtExH -identifies L}. One can similarly define InfExH -identification, where one replaces texts in the above definition by informants. As the learner has seen only finitely many inputs before it converges to its final hypothesis, some form of learning must have taken place. We use the terms identify, learn, infer as synonyms for this reason.

Hypothesis Spaces for Learning

45

Note that in the above model of learning, the learner does not know when it has converged to its final hypothesis. If one additionally requires this kind of ability from the learner, then the learning criterion is equivalent to finite learning, where the learner is allowed to make only one conjecture. Definition 2. [16] Fix a hypothesis space H = H0 , H1 , . . .. (a) A learner M TxtFinH -identifies a language L (written: L ∈ TxtFinH (M )) iff for all texts T for L, there exist i, n such that (i) Hi = L, (ii) (∀m < n)[M (T [m]) =?], and (iii) (∀m ≥ n)[M (T [m]) = i]. (b) A learner M TxtFinH -identifies a class L of languages (written: L ⊆ TxtFinH (M )) iff it TxtFinH -identifies all languages in the class L. (c) TxtFinH = {L : (∃M )[M TxtFinH -identifies L}. One can similarly define InfFinH -identification. Since Gold [16], various other criteria of learning have been explored in the literature, specially those which require some additional properties on the conjectures of the learner. We will consider some of them in Section 2. We refer the reader to [3,6,11,19,38,40,43] for some literature on the topic. Note that the hypothesis space chosen for interpreting the conjectures of the learner may play a crucial role in whether the learner is successful in identifying the language. A commonly used hypothesis space is the standard acceptable programming system: W0 , W1 , . . . (see [34]). The class TxtEx does not depend on the exact acceptable programming system chosen, as the acceptable programming system can be translated effectively into each other. However, if one considers other programming systems such as Friedberg numbering [13] as hypothesis space or requires some other properties (such as membership question about hypotheses being decidable, or whether the hypothesis space depends on the class being learnt (for example, not allowing the hypothesis space to contain languages other than those in the class of languages under consideration)), then it may effect the classes which are learnable. This paper surveys some of the results which show how learnability depends on the type of hypothesis spaces allowed. In Section 2 we define some commonly used criteria of learning. In section 3 we consider the special case of learning indexed families, where often the hypothesis space allowed depends on the class of languages being learnt. In section 4 we consider hypothesis spaces being restricted programming systems, such as Friedberg numberings. In section 5 we consider whether learning is at all possible if one requires learning in all (reasonable) possible hypothesis spaces. In section 6 we consider optimal hypothesis spaces in the sense that if learning a class is possible using any hypothesis space, then the class can be learnt using the given hypothesis space. In the rest of the paper, for ease of notation, we will omit the hypothesis space from the subscript of learning criteria, and it will be implicit (the allowed hypothesis space may be constrained in some cases due to conventions of the section).

46

2

S. Jain

Some Further Criteria of Learning

Below we consider the criteria mainly for learning from texts. Similar definitions can be made for learning from informants also. Below, let H = H0 , H1 , . . . be the hypothesis space used by the learner. We first consider two generalizations of explanatory learning. The following generalization considers semantic convergence rather than syntactic convergence to the correct hypothesis by the learner. A learner M is said to behaviourally correctly learn (abbreviated: TxtBc-learn) [5,10] a language L iff for all texts T for L, for all but finitely many n, HM(T [n]) = L. One can similarly define TxtBc learning of a class, and TxtBc the set of all behaviourally correctly learnable classes. It can be shown that TxtBc is a strict generalization of TxtEx-learning if one allows arbitrary hypothesis spaces [11,5]. The following criterion is somewhere between explanatory and behaviourally correct learning. It allows the learner to eventually vacillate between finitely many correct hypotheses. A learner M is said to vacillatory learn (abbreviated: TxtFex-learn) [8] a language L iff it TxtBc-learns the language L and on all texts T for L, it outputs at most finitely many distinct grammars (in other words, the learner eventually vacillates between finitely many correct grammars for the language). One can similarly define TxtFex learning of a class, and TxtFex the set of all vacillatorily learnable classes. We now turn our attention to requiring some properties that the learner (its hypotheses) must satisfy. A learner M is said to be conservative [2] on L if for all texts T for L, for all m > n, if M (T [n]) = M (T [m]), then content(T [m]) ⊆ HM(T [n]) . That is, M changes its hypothesis only if it finds evidence of inconsistency of its earlier conjecture. Learner M conservatively learns (Conserv-identifies) L if it TxtEx-identifies L and is conservative on L. Conserv-identification of a class of languages and the class Conserv can be defined similarly. When using acceptable numberings as hypothesis spaces, requiring learners to be conservative is a restriction on the learning capabilities of the machines [2]. A learner M is said to be strong monotonic [17] on L if for all texts T for L, for all m > n, HM(T [n]) ⊆ HM(T [m] . A learner M is said to be monotonic [39] on L if for all texts T for L, for all m > n, HM(T [n]) ∩ L ⊆ HM(T [m] ∩ L. A learner M is said to be weak monotonic [17] on L if for all texts T for L, for all m > n, if content(T [m]) ⊆ HM(T [n]) , then HM(T [n]) ⊆ HM(T [m] (that is the learner behaves strong monotonically as long as the input data does not contradict the hypothesis conjectured). The criteria of learning corresponding to the above properties being satisfied by the learner, in addition to TxtExlearning the target language, are respectively called SMon, Mon and WMon. Let L denote N − L, the complement of L. [31] considered the dual of above monotonic requirements, where for dual strong monotonic learning of L one requires that for all texts T for L, for all m > n, HM(T [n]) ⊆ HM(T [m] . Similarly, for dual monotonic learning of L one requires that for all texts T for L, for all m > n, HM(T [n]) ∩ L ⊆ HM(T [m] ∩ L, and for dual weak monotonic learning of L one requires that for all texts T for L, for all m > n, if content(T [m]) ⊆ HM(T [n]) , then HM(T [n]) ⊆ HM(T [m] . The criteria of learning corresponding to the above

Hypothesis Spaces for Learning

47

properties being satisfied by the learner, in addition to TxtEx-learning the target language, are respectively called DSMon, DMon and DWMon. [31] explore the relationship between the above (dual) monotonic criteria of learning. A learner M is consistent [1,4] on L if for all texts T for L, for all n, content(T [n]) ⊆ HM(T [n]) . Consistency seems like a natural requirement, as if the hypothesis is not consistent, then it is obviously wrong. However, when using general hypothesis spaces such as acceptable numberings, it can be shown that requiring consistency restricts learning capabilities of the machines [4]. A learner M is confident [33] if it converges on every text, even if the text is for a language outside the class of languages being learnt. Confidence is restrictive: it can be shown that even simple classes, such as the class of all finite languages, cannot be learnt confidently. One can define the corresponding learning criteria for learners satisfying consistency and confidence properties (for I-learning) similarly. These criteria are called respectively ConsI and ConfI. A learner M is set-driven [36,32] if content(σ) = content(τ ) implies M (σ) = M (τ ). That is the output of the learner depends only on the content of the input, and not on its length or order. For acceptable programming systems as hypothesis space, it can be shown that set drivenness restricts the learning capabilities of machines [35]. A learner M is rearrangement-independent [6,14] if content(σ) = content(τ ) and length(σ) = length(τ ), implies M (σ) = M (τ ). That is the output of the learner depends only on the content and length of the input, and not on the order of the elements in it. Unlike most other requirements considered, rearrangement independence is not restrictive for explanatory learning [14], when one considers acceptable numberings as hypothesis spaces. One can define the corresponding learning criteria for learners satisfying set drivenness and rearrangement independence (for I-learning) similarly. These criteria are called s-I and r-I.

3

Learning Indexed Families

Angluin [2] considered learnability of indexed family of recursive languages. A class of languages L consisting of languages L0 , L1 , . . . (with the corresponding indexing) is said to be an indexed family iff there exists a recursive function f such that f (i, x) = 1 iff x ∈ Li . Many of the commonly studied classes of languages, such as the class of regular languages or context free languages, are indexed families. For learning indexed families, the hypothesis space is usually considered to be an indexed family also. Additionally, one often considers the following requirements (see [25,27]): (a) the hypothesis space is the class being learnt (with the corresponding indexing) itself; this is called exact learning; (b) the hypothesis space is class preserving, that is {H0 , H1 , . . .} = {L0 , L1 , . . .}; this is called class preserving learning;

48

S. Jain

(c) the hypothesis space is class comprising, that is {H0 , H1 , . . .} ⊇ {L0 , L1 , . . .}; this is called class comprising learning. Note that in (b) and (c), there are several possible hypothesis spaces that might be used — if learning can be successfully done with respect to any of such hypothesis spaces, then one considers the class to be learnable according to the corresponding criterion. We prefix E,  or C (where  denotes empty string) to the names of the criteria of learning to denote whether we are considering exact, class preserving or class comprising learning. This convention on criteria names is for this section only. Lange and Zeugmann [25,27] showed that ETxtEx = TxtEx = CTxtEx and ETxtFin = TxtFin = CTxtFin. Thus, for explanatory and finite learning, choosing an appropriate hypothesis space (in the sense of exact, class preserving or class comprising) is not so crucial. However, for monotonic learning, the choice of different kind of hypothesis spaces makes a critical difference. Theorem 3. The following relations hold: (a) [25] ESMon ⊂ SMon ⊂ CSMon. (b) [25] EWMon ⊂ WMon ⊂ CWMon. (c) [25] EDWMon ⊂ DWMon ⊂ CDWMon. (d) [25] EDSMon = DSMon ⊂ CDSMon. (e) [31,26] EMon ⊂ Mon ⊂ CMon. (f ) EDMon ⊂ DMon ⊂ CDMon. Proof of Theorem 4 in [26] shows that EDMon ⊂ DMon. We do not know if anyone has explicitly shown that DMon ⊂ CDMon, but it can be shown as follows. Here we do the diagonalization even against DMon learners using some (class preserving) r. e. indexing of languages as hypothesis space. Thus, we can consider the hypothesis of the learner as coming from an acceptable programming system, where the learner only conjectures grammars for the languages in the class being learnt. Let ·, · denote some computable bijective coding from N × N to N. Similarly, ·, ·, · denotes some computable bijective coding from N × N × N to N. Let Li = { i, 0, x : x ∈ N}, Li,j = { i, 0, x : x ≤ j}, Xi,j,k = Li,j ∪ { i, 1, x : x ≥ k}, and Xi,j,k,k = Li,j ∪ { i, 1, x : k ≤ x ≤ k  } ∪ { i, 2, k}. Let M0 , M1 , . . . denote a recursive enumeration of all learning machines. Let Ti be the canonical text for Li given by Ti (j) = i, 0, j. Let si > 0 denote the first s found, if any in some standard search, such that content(Ti [s]) ∪ { i, 0, s} ⊆ WMi (Ti [s]) . Let ri denote the time needed to find si , if defined (where we assume ri ≥ si ). Let L = {Li : i ∈ N and for all s, content(Ti [s]) ∪ { i, 0, s} ⊆ WMi (Ti [s]) } ∪ {Li,ri : i ∈ N and si is defined} ∪ {Xi,si −1,ri : i ∈ N and si is defined} ∪ {Xi,si −1,ri ,k : i ∈ N and si is defined, k ∈ N}. It is easy to verify that L is an indexed family. Note that if si is defined then Li,ri is the only language in L which contains i, si . Thus, L cannot be DMonidentified. (If si is not defined, then Mi does not TxtEx-identify Li ∈ L. If si is

Hypothesis Spaces for Learning

49

defined then Mi on input Ti [si ] has already conjectured a language which omitted every element in { i, 1, x : x ∈ N}. Thus, it will fail to dual monotonically learn {Xi,si −1,ri : i ∈ N and si is defined} ∪ {Xi,si −1,ri ,k : i ∈ N and si is defined, k ∈ N}.) On the other hand, with class comprising hypothesis space, one can easily dual monotonically learn the above class: initial conjecture (on input containing elements of form i, ·, ·) would be Li ∪ (Xi,si −1,ri ∪ { i, 2, ri }) (where (Xi,si −1,ri ∪ { i, 2, ri }) is taken to be empty set, if si does not get defined). If and when si is defined, the learner waits until it gets i, 0, si , i, 1, ri , or i, 2, k in the input. At which point it can easily dual monotonically identify the input. [42] gave some interesting characterization of classes which are (strong, weak) monotonically learnable in dependence of hypothesis space. Even though TxtEx does not depend on whether one chooses class preserving, exact or class comprising hypothesis space, if one considers restricting the number of mind changes to a non-zero value, then learnability does depend on what kind of hypothesis space one chooses. Let TxtExm (see [11]) denote the criterion of learning where the learner is allowed at most m mind changes (here a change from ? to a proper conjecture (member of N) is not counted as a mind change). Theorem 4. Suppose m ≥ 1. (a) [27] ETxtExm ⊂ TxtExm . (b) TxtExm ⊂ CTxtExm . We do not know if anyone has explicitly shown that TxtExm ⊂ CTxtExm , but it can be shown as follows. Let M0 , M1 , . . . denote a recursive enumeration of all learning machines. Let Li = { i, x : x ∈ N}, and LD i,j = { i, x : x ≤ j or x ∈ D}. Let Ti be the canonical text for Li given by Ti (j) = i, j. Let si > 0 denote the first s found, if any, such that Mi (Ti [s]) outputs a conjecture containing i, 0. If si gets defined, then let ri be the number of steps needed to find that si is defined (we assume ri ≥ si ). If si is defined, then let wi denote the least x ≥ ri + 1, if any, such that i, x ∈ WMi (Ti [si ]) . Let ri denote the number of steps needed to find wi , if defined. If si is not defined, then let Li = {Li }. If si is defined, but wi does not {r +1} get defined, then let Li = {Li,rii }. If si and wi both get defined, then let  {ri +1}  Li = {Li,ri }∪{LD i,ri : card(D) ≤ m+1, wi +ri +1 = min(D)}. Let L = i Li . It is easy to verify that L is an indexed family, and L ∈ CTxtExm . However L ∈ TxtExm (using a class preserving hypothesis space), as either si is not defined (and thus Mi does not TxtEx-identify Li ∈ Li ) or the conjecture output  by Mi on Ti [si ] is not for any language in {LD i,ri : card(D) ≤ m + 1, wi + ri + 1 = D min(D)}, which forces at least m + 1 mind changes to learn {Li,ri : card(D) ≤ m + 1, wi + ri + 1 = min(D)}. If one considers iterative learning (where the learner’s hypotheses depend only on its last hypothesis and current data, rather than all the data it has seen so far) [37,28], then [28] showed that for certain classes and particular class comprising hypothesis spaces iterative learning may outperform conservative

50

S. Jain

learning, though in general iterative learning is contained in conservative learning (for class comprising hypothesis spaces). [31] also studied how the structure of relationship between various versions of monotonicity/dual monotonicity changes if one considers class comprising hypothesis space as opposed to class preserving/exact hypothesis spaces. For example, CTxtFin ⊂ CDMon, though TxtFin = DMon. Similarly, – CDWMon = CTxtEx, though DWMon ⊂ TxtEx, – and DSMon ⊂ SMon, though CDSMon and CSMon are incomparable. Thus, not only do the classes learnable (under a learning criterion) depend on the kind of hypothesis spaces that are allowed, but even the relationship among the learning criteria depend on what kind of hypothesis spaces are allowed. In [29] the authors study set driven and rearrangement independent learning in dependence of hypothesis space for indexed families (hypothesis space being indexed family too). They showed that for set driven and rearrangement independent learning, the classes that can be finitely learnt does not depend on the type of hypothesis spaces allowed (among the types, exact, class preserving and class comprising). Theorem 5. [29] r-ETxtFin = s-ETxtFin = ETxtFin = TxtFin = CTxtFin. For explanatory learning, set driven learning forms a hierarchy depending on the type of hypothesis space allowed, whereas for rearrangement independent learning, it does not depend on the type of hypothesis space allowed. Theorem 6. [29] (a) s-ETxtEx ⊂ s-TxtEx ⊂ s-CTxtEx ⊂ ETxtEx = TxtEx = CTxtEx. (b) r-ETxtEx = r-TxtEx = r-CTxtEx = ETxtEx = TxtEx = CTxtEx. For monotonic learning (all three types) we get a proper hierarchy for both set driven as well as rearrangement independent learning. Theorem 7. [29] (a) s-ESMon ⊂ s-SMon ⊂ s-CSMon. (b) s-EMon ⊂ s-Mon ⊂ s-CMon. (c) s-EWMon ⊂ s-WMon ⊂ s-CWMon. (d) r-ESMon ⊂ r-SMon ⊂ r-CSMon. (e) r-EMon ⊂ r-Mon ⊂ r-CMon. (f ) r-EWMon ⊂ r-WMon ⊂ r-CWMon. We refer the reader to [41] for several other results and characterizations for learning indexed family in dependence on hypothesis spaces. [30] considered the situation where the learner may make queries regarding certain kind of relationship between a potential hypothesis and the input language. The queries allowed are subset, superset or disjointness queries. The learner, after making a finite number of such queries, outputs a single hypothesis

Hypothesis Spaces for Learning

51

which must be correct for languages in the class being learnt. They showed that the learnability of a class depends very much on whether the hypothesis space (query space) chosen is an indexed family, recursively enumerable (r.e.) family or a limiting r. e. family. [18] extended above work to learning r.e. classes of r.e. languages.

4

Special Hypotheses Spaces

In this section we revert back to learning recursively enumerable languages with respect to some fixed hypothesis spaces. Criteria I (such as TxtEx, TxtBc, TxtFin, or TxtFex) without a specified hypothesis space refers to using acceptable numbering as hypothesis space. A universal numbering is a numbering which contains an index for every recursively enumerable set. Friedberg numberings [13] are universal numberings in which every r.e. language has exactly one index. Friedberg numberings can in some sense be considered “efficient” as they do not have any redundancy. Ke-numberings [21] are universal numberings for which grammar equivalence problem for indices is limiting recursive. Jain and Stephan [21] considered learning using Friedberg numberings or Kenumberings as hypothesis spaces. ([12] considered learning of functions using Friedberg numberings as hypothesis spaces). For a criteria I of learning, let FrI (KeI) denote the class of languages which can be learnt under the criteria I using some Friedberg numbering (some Ke-numbering) as hypothesis space. [21] showed that every TxtEx-learnable class can be learnt using some Friedberg numbering as hypothesis space. However, no single Friedberg numbering is enough to be used as hypothesis space for all TxtEx-learnable classes. On the other hand, for finite learning, there are classes of languages which can be finitely learnt (using acceptable numbering as hypothesis spaces), but which cannot be learnt using any Friedberg numbering as hypothesis space. On the other hand, every finitely learnable class can be learnt using some Ke-numbering as hypothesis space. Theorem 8. [21] FrTxtEx = KeTxtEx = TxtEx. FrTxtFin ⊂ KeTxtFin = TxtFin. An interesting result shown by [21] is that a recursively enumerable class can be finitely learnt using some Friedberg numbering as hypothesis space iff it is 1–1 recursively enumerable and finitely learnable. On the other hand, the situation changes for vacillatory and behaviourally correct learning. There exist behaviourally correctly learnable classes which cannot be behaviourally correctly learnt in any Friedberg numbering. Theorem 9. [21] FrTxtBc ⊂ KeTxtBc. It is open at this point whether every behaviourally correctly learnable class is behaviourally correctly learnable in some Ke numbering.

52

S. Jain

On the other hand, for vacillatory learning, there are vacillatorily learnable classes which cannot be vacillatorily learnt in any Ke-numbering. In particular, every class which can be vacillatorily learnt in some Ke-numbering is explanatorily learnable! Theorem 10. [21] FrTxtFex = KeTxtFex = TxtEx ⊂ TxtFex. (Here TxtEx ⊂ TxtFex was shown by [8]). Even though every TxtEx-learnable class is learnable using some Friedberg numbering, the learner may not satisfy some desirable properties. For example, consider non-U-shaped learning. Non-U-shaped learning requires that a learner never abandons a correct hypotheses [7]. Every TxtEx-learnable class can also be learnt in a non-U-shaped way using some acceptable numbering as hypothesis space [7]. However, even some simple classes, such as the class of all finite sets, cannot be learnt in non-U-shaped way using any Friedberg numbering as hypothesis space. (However, one can do non-U-shaped learning of every TxtExlearnable class using some Ke-numbering as hypothesis space.) Similar results hold if one considers conservative, monotonic or prudent learning (where in prudent learning [33], the learner is allowed to output conjectures only for languages which it learns). However, for consistent learning [1,4] one can use Friedberg numbering as hypothesis space for every class of languages which can be consistently learnt using some hypothesis space. In contrast to the power of using Friedberg numberings in general, there are some Friedberg numberings which make learning almost impossible: only TxtEx-learnable classes which contain finitely many infinite languages could be (explanatorily, behaviourally correctly, or vacillatorily) learnt using such Friedberg numberings as hypothesis space. Similarly, there exist Friedberg numberings, using which as hypothesis space, only inclusion free finite classes of languages can be finitely learnt (a class is inclusion free if no language in the class is included in another language in the class). We refer the reader to [21] for further results on learning using a Friedberg or Ke-numbering as hypothesis spaces.

5

Prescribed Learning

Until now we have been mostly concentrating on learning using some suitable hypothesis space, perhaps with some constraints such as being class preserving, class comprising or being a Friedberg numbering. What if one requires that the learning has to happen with respect to every suitable hypothesis space? This kind of situation is useful if one expects that the seller provides a learner which works based on the programming system used by any potential buyer, rather than only with the programming system used by the seller. Here one may distinguish between two cases, one where there exists a learner for each of the suitable hypothesis spaces and where one expects the same learner (with hypothesis space being a parameter) to work for all hypothesis spaces. The issue here is of being able to effectively generate a learner given a description of the suitable hypothesis space. Jain, Stephan and Ye [24,23] considered the above situation.

Hypothesis Spaces for Learning

53

We say that a class L is prescribed I learnable, if for every hypothesis space H ⊇ L, L can be learnt according to the criterion I using H as hypothesis space. We say that a class L is class-preserving-prescribed I learnable, if for every class preserving hypothesis space H (that is H = L, set wise; the indexing may be different), L can be learnt according to criterion I using H as hypothesis space. We say that L is uniformly I learnable, if there exists an effective listing M0 , M1 , M2 , . . . of learners such that given a program i describing the hypothesis space H ⊇ L, L can be learnt by Mi according to criterion I using H as hypothesis space. Here we say that the program i describes the hypothesis space H if ϕi (j, x) = 1 iff x ∈ Hj (where, when considering indexed family as hypothesis space, we require ϕi to be total). In above, ϕi denotes the function computed by the i-th program in some standard acceptable programming system. One can define uniformly class-preserving learning similarly. For general learnability of r.e. languages, where hypothesis spaces are r.e. classes (rather than indexed families) prescribed learning is quite weak as in some Friedberg numberings only restricted classes can be learnt. Thus, for r.e. languages one normally considers class-preservingly-prescribed (uniformly classpreserving) learning only. Note that the concept class being considered here would be r.e. classes of r.e. languages. For finite and explanatory learning, uniform learning can very much be done. Theorem 11. [23] Every TxtFin-learnable r.e. class of languages is also uniformly class-preservingly TxtFin learnable. Theorem 12. [23] Every TxtEx-learnable r.e. class of languages is also uniformly class-preservingly TxtEx-learnable. For confident learning, there are classes which are class comprisingly confidently learnable but not class preservingly confidently learnable. So we have a restricted version of the above theorems for confident learning. Theorem 13. [23] Every class-preservingly confident learnable r.e. class of languages is also uniformly class-preservingly confidently learnable. [23] also consider behaviourally correct learning and vacillatory learning. Though these criteria are similar to explanatory learning (in semantic sense), it was shown that there are classes behaviourally correctly learnable using classpreserving hypothesis spaces but not class-preservingly-prescribed behaviourally correctly learnable. It is open at this point whether uniform and non-uniform prescribed version of class-preserving learning for behaviourally correct learning are same. Similar question for vacillatory learning is also open. On the other hand, for conservative learning, prescribed and uniform learning are a restriction and are separated from each other. Theorem 14. [23] (a) The class {D : |D| ≤ 1} is class-preservingly-prescribed conservatively but not uniformly class-preservingly conservatively learnable.

54

S. Jain

(b) The class {D : |D| < ∞} is class-preservingly conservatively but not classpreservingly-prescribed conservatively learnable. (c) The class {D : |D| = 2 ∨ (|D| = 1 ∧ D ⊆ K  )} is class-comprisingly conservatively but not class-preservingly conservatively learnable. We now turn our attention to prescribed learning of indexed families. Rest of the section considers learning of indexed families only. Thus, as in Section 3, the hypothesis spaces are assumed to be indexed families. For finite learning, prescribed and uniform learning are very restricted. However, uniform class-preserving learning can be done for all finitely learnable indexed families. Theorem 15. [24] Suppose L is a finitely learnable indexed family. (a) Any non-empty L is not uniformly finitely learnable. (b) L is uniformly class-preservingly finitely learnable. (c) L is prescribed finitely learnable iff the class is finite and inclusion free (that is, any two distinct languages in the class are incomparable by ⊆). For conservative learning, uniform and prescribed learning imply that (almost) all the languages in the class are cofinite. Theorem 16. [24] (a) If L is uniformly conservatively learnable then every L ∈ L is cofinite. (b) If L is prescribed conservatively learnable then all but finitely many languages L ∈ L are cofinite. Furthermore, uniformly class-preserving conservative learning and prescribed conservative learning are incomparable. Theorem 17. [24] (a) There exists a class L which is uniformly class-preservingly conservatively learnable, but not prescribed conservatively learnable. (b) There exists a class L which is prescribed conservatively learnable but not uniformly class-preservingly conservatively learnable. We now consider the effect of prescribing the hypothesis space for monotonic learning. Theorem 18. [24] (a) Any non-empty L is not uniformly strong-monotonically learnable. (b) L is prescribed strong-monotonically learnable iff L is finite. On the other hand, the class L = {Li : i ∈ N}, where Li = {i}, is uniformly monotonically learnable. In contrast to conservative learning, for monotonic learning, uniform learnability implies that the languages in the class are finite.

Hypothesis Spaces for Learning

55

Theorem 19. [24] (a) If L is uniformly monotonically learnable, then L contains only finite sets. (b) If L is prescribed monotonically learnable, then L contains only finitely many infinite sets. Theorem 20. [24] (a) There exists a class L which is uniformly class-preservingly strongmonotonically learnable but not prescribed monotonically learnable. (b) There exists a class L which is prescribed monotonically learnable but not uniformly class-preservingly monotonically learnable. (c) Every prescribed strong-monotonically learnable class is also uniformly classpreservingly strong-monotonically learnable.

6

Optimal Hypotheses Spaces

As we have seen, chosen hypothesis spaces play a crucial role in whether a learner is able to learn the target class of languages. In this section we consider whether there are hypothesis spaces H which are optimal, in the sense that any class learnable using any hypothesis space is also learnable using the hypothesis space H. This ofcourse depends on the criterion under investigation. Furthermore, we consider whether an hypothesis space being optimal for a particular criterion implies it being optimal for some other criterion. Such studies were done by [22]. For a criteria of learning I, an hypothesis space H is said to be optimal if any class L, I-learnable using some hypothesis space, is also I learnable using H as hypothesis space. The hypothesis space H is said to be effectively optimal for a criteria I if given any learner M using hypothesis space H , one can effectively find a learner M  using H as hypothesis space (for the class of languages which was I-learnt by M using H as hypothesis space). Clearly, all acceptable numberings are optimal. Are there other optimal numberings? Definition 21. [22] A numbering A0 , A1 , A2 , . . . is called nearly acceptable iff there is a recursive function f such that Af (d,e) = We whenever d ∈ We . The nearly optimal numberings are effectively optimal for explanatory, vacillatory and behaviourally correct learning. They are also optimal for finite learning, but not necessarily effectively optimal for finite learning. Note that one can easily construct nearly acceptable numberings which are not acceptable. The effectively optimal numberings for finite, explanatory and vacillatory learning are easy to characterize. A numbering ψ is said to be K-acceptable [9] iff for any further numbering η, there exists a limiting recursive compiler [25] translating the indices of η to indices of ψ. Theorem 22. [22] A hypothesis space H = H0 , H1 , H2 , . . . of all r.e. sets is (a) effectively optimal for finite learning iff H is acceptable; (b) effectively optimal for explanatory learning iff H is K-acceptable;

56

S. Jain

(c) effectively optimal for vacillatory learning iff there is a limiting-recursive function g such that, for all d, there is an e ≤ g(d) with He = Wd . The following theorem gives the relation between optimal numberings for finite, explanatory, behaviourally correct and vacillatory learning. Theorem 23. [22] (a) For each I ∈ {TxtEx, TxtFin, TxtBc, TxtFex}, there are numberings which are optimal but not effectively optimal for I. (b) For any two distinct I and J in {TxtEx, TxtFin, TxtBc, TxtFex}, there is a numbering which is optimal for I but not optimal for J. In (b) above, if I = TxtFin and (I = TxtEx or J = TxtFex), then we can even take the numbering to be effective optimal for I. Another interesting result is that every (effectively) optimal numbering for TxtEx is also (effectively) optimal for consistent learning. On the other hand there are numberings which are effectively optimal for consistent learning but not optimal for finite, explanatory, vacillatory or behaviourally correct learning. In learning with additional information, in addition to text for the language, learner is also provided with an upper bound on a grammar (in the hypothesis space) for the target language [15,20]. [22] showed that the Ke-numberings are exactly those hypothesis spaces which are optimal for learning with additional information. Acknowledgements. We thank Frank Stephan for helpful discussions and comments.

References 1. Angluin, D.: Finding patterns common to a set of strings. Journal of Computer and System Sciences 21, 46–62 (1980) 2. Angluin, D.: Inductive inference of formal languages from positive data. Information and Control 45, 117–135 (1980) 3. Angluin, D., Smith, C.: Inductive inference: Theory and methods. Computing Surveys 15, 237–289 (1983) 4. B¯ arzdi¸ nˇs, J.: Inductive inference of automata, functions and programs. In: Proceedings of the 20th International Congress of Mathematicians, Vancouver, pp. 455–560 (1974); (in Russian) English translation in American Mathematical Society Translations. Series 2 109, 107–112 (1977) 5. B¯ arzdi¸ nˇs, J.: Two theorems on the limiting synthesis of functions. Theory of Algorithms and Programs 1, 82–88 (1974) (in Russian) 6. Blum, L., Blum, M.: Toward a mathematical theory of inductive inference. Information and Control 28, 125–155 (1975) 7. Baliga, G., Case, J., Merkle, W., Stephan, F., Wiehagen, R.: When unlearning helps. Information and Computation 206(5), 694–709 (2008) 8. Case, J.: The power of vacillation in language learning. SIAM Journal on Computing 28(6), 1941–1969 (1999) 9. Case, J., Jain, S., Suraj, M.: Control structures in hypothesis spaces: The influence on learning. Theoretical Computer Science 270(1–2), 287–308 (2002)

Hypothesis Spaces for Learning

57

10. Case, J., Lynes, C.: Machine inductive inference and language identification. In: Nielsen, M., Schmidt, E.M. (eds.) ICALP 1982. LNCS, vol. 140, pp. 107–115. Springer, Heidelberg (1982) 11. Case, V., Smith, C.: Comparison of identification criteria for machine inductive inference. Theoretical Computer Science 25, 193–220 (1983) 12. Freivalds, R., Kinber, E., Wiehagen, R.: Inductive inference and computable oneone numberings. Zeitschr. f. math. Logik und Grundlagen d. Math. Bd. 28, 463–479 (1982) 13. Friedberg, R.: Three theorems on recursive enumeration. Journal of Symbolic Logic 23(3), 309–316 (1958) 14. Fulk, M.: Prudence and other conditions on formal language learning. Information and Computation 85, 1–11 (1990) 15. Freivalds, R., Wiehagen, R.: Inductive inference with additional information. Journal of Information Processing and Cybernetics (EIK) 15, 179–195 (1979) 16. Gold, E.M.: Language identification in the limit. Information and Control 10, 447– 474 (1967) 17. Jantke, K.: Monotonic and non-monotonic inductive inference. New Generation Computing 8, 349–360 (1991) 18. Jain, S., Lange, S., Zilles, S.: A general comparision of language learning from examples and from queries. Theoretical Computer Science A 387(1), 51–66 (2007); Special Issue on Algorithmic Learning Theory (2005) 19. Jain, S., Osherson, D., Royer, J., Sharma, A.: Systems that Learn: An Introduction to Learning Theory, 2nd edn. MIT Press, Cambridge (1999) 20. Jain, S., Sharma, A.: Learning with the knowledge of an upper bound on program size. Information and Computation 102, 118–166 (1993) 21. Jain, S., Stephan, F.: Learning in Friedberg numberings. Information and Computation 206(6), 776–790 (2008) 22. Jain, S., Stephan, F.: Numberings optimal for learning. In: Gy¨ orfi, L., Freund, Y., Tur´ an, G., Zeugmann, T. (eds.) ALT 2008. LNCS (LNAI), vol. 5254, pp. 434–448. Springer, Heidelberg (2008) 23. Jain, S., Stephan, F., Ye, N.: Prescribed learning of R.E. classes. In: Hutter, M., Servedio, R., Takimoto, E. (eds.) ALT 2007. LNCS (LNAI), vol. 4754, pp. 64–78. Springer, Heidelberg (2007) 24. Jain, S., Stephan, F., Ye, N.: Prescribed learning of indexed families. Fundamenta Informaticae 83(1–2), 159–175 (2008) 25. Lange, S., Zeugmann, T.: Language learning in dependence on the space of hypotheses. In: Proceedings of the Sixth Annual Conference on Computational Learning Theory, pp. 127–136. ACM Press, New York (1993) 26. Lange, S., Zeugmann, T.: The learnability of recursive languages in dependence on the space of hypotheses. Technical Report 20/93, GOSLER-Report, FB Mathematik und Informatik, TH Lepzig (1993) 27. Lange, S., Zeugmann, T.: Learning recursive languages with bounded mind changes. International Journal of Foundations of Computer Science 4, 157–178 (1993) 28. Lange, S., Zeugmann, T.: Incremental learning from positive data. Journal of Computer and System Sciences 53, 88–103 (1996) 29. Lange, S., Zeugmann, T.: Set-driven and rearrangement-independent learning of recursive languages. Mathematical Systems Theory 29, 599–634 (1996) 30. Lange, S., Zilles, S.: Comparison of query learning and gold-style learning in dependence of the hypothesis space. In: Ben-David, S., Case, J., Maruoka, A. (eds.) ALT 2004. LNCS (LNAI), vol. 3244, pp. 99–113. Springer, Heidelberg (2004)

58

S. Jain

31. Lange, S., Zeugmann, T., Kapur, S.: Monotonic and dual monotonic language learning. Theoretical Computer Science A 155, 365–410 (1996) 32. Osherson, D., Stob, M., Weinstein, S.: Learning strategies. Information and Control 53, 32–51 (1982) 33. Osherson, D., Stob, M., Weinstein, S.: Systems that Learn: An Introduction to Learning Theory for Cognitive and Computer Scientists. MIT Press, Cambridge (1986) 34. Rogers, H.: Theory of Recursive Functions and Effective Computability. McGrawHill, New York (1967); reprinted by MIT Press (1987) ¨ 35. Sch¨ afer-Richter, G.: Uber Eingabeabh¨ angigkeit und Komplexit¨ at von Inferenzstrategien. PhD thesis, RWTH Aachen (1984) 36. Wexler, K., Culicover, P.: Formal Principles of Language Acquisition. MIT Press, Cambridge (1980) 37. Wiehagen, R.: Limes-Erkennung rekursiver Funktionen durch spezielle Strategien. Journal of Information Processing and Cybernetics (EIK) 12, 93–99 (1976) 38. Wiehagen, R.: Zur Theorie der Algorithmischen Erkennung. Dissertation B, Humboldt University of Berlin (1978) 39. Wiehagen, R.: A thesis in inductive inference. In: Dix, J., Jantke, K., Schmitt, P. (eds.) NIL 1990. LNCS (LNAI), vol. 543, pp. 184–207. Springer, Heidelberg (1991) 40. Wiehagen, R., Zeugmann, T.: Learning and consistency. In: Jantke, K.P., Lange, S. (eds.) GOSLER 1994. LNCS (LNAI), vol. 961, pp. 1–24. Springer, Heidelberg (1995) 41. Zeugmann, T., Lange, S.: A guided tour across the boundaries of learning recursive languages. In: Jantke, K., Lange, S. (eds.) GOSLER 1994. LNCS (LNAI), vol. 961, pp. 190–258. Springer, Heidelberg (1995) 42. Zeugmann, T., Lange, S., Kapur, S.: Characterizations of monotonic and dual monotonic language learning. Information and Computation 120, 155–173 (1995) 43. Zeugmann, T., Zilles, S.: Learning recursive functions: A survey. Theoretical Computer Science A 397(1–3), 4–56 (2008); Special Issue on Forty Years of Inductive Inference. Dedicated to the 60th Birthday of Rolf Wiehagen

State Complexity of Nested Word Automata Kai Salomaa School of Computing, Queen’s University, Kingston, Ontario K7L 3N6, Canada [email protected]

Abstract. We discuss techniques to establish lower bounds for the number of states of finite automata operating on nested words. To illustrate these methods we establish a lower bound for the state complexity of Kleene star that is of a different order than the known tight state complexity bound for the star of ordinary regular languages. We survey known bounds on deterministic and nondeterministic state complexity of basic operations on regular nested word languages and discuss open problems.

1

Introduction

Finite automata operating on nested words have been introduced by Alur and Madhusudan [4,5] as a natural extension of ordinary finite automata. The symbols of a nested word are ordered in the standard way linearly, and additionally there is a recursively defined matching of occurrences of special call and return symbols. Automata on nested words provide a natural computational model for applications like XML document processing, where data has a dual linearhierarchical structure. The class of regular nested word languages retains many desrirable properties of classical regular languages, in particular, closure and decision properties. More information on applications of nested word automata and on related models can be found e.g. in [1,2,6]. The state complexity of basic operations on regular languages has been extensively studied, see for example [15,17,19,21,22,29,31]. Generally when considering various extensions of finite automata, naturally one of the first questions to be answered could be which properties turn out to be significantly different for the extended model. Tree automata [13] are another much studied model extending ordinary finite automata. As regards Boolean operations or the extension of concatenation and Kleene star to trees, it can be expected that the state complexity results for tree automata1 would be essentially similar as for ordinary finite automata. Interestingly, for nested word automata the lower bounds for deterministic state complexity of, for example, catenation and Kleene star turn out to be of a different order than the corresponding results for ordinary regular  1

Research supported by the Natural Sciences and Engineering Research Council of Canada. However, the author is not aware of work explicitly discussing the state complexity of operations on regular tree languages.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 59–70, 2009. c Springer-Verlag Berlin Heidelberg 2009 

60

K. Salomaa

languages. It can be noted that (ranked or unranked) trees can be viewed as special cases of nested words [5]. Recently, it has been established in [12] that nested word automata are equivalent to pushdown forest automata [25]. It is shown in [5] that a deterministic nested word automaton equivalent to 2 a given nondeterministic automaton with O(n) states may need 2n states. The fact that the state complexity blow-up is larger than in the case of ordinary finite automata, intuitively, causes the possibility that the known upper bounds for the state complexity of basic operations on regular languages [29] need not, in general, hold for languages of nested words. Even in the case of ordinary deterministic finite automata (DFA), worst-case state complexity examples for various operations are often difficult to construct and software tools, such as Grail+, are used for verifying worst-case examples [11,28,30]. The fact that DFAs can be minimized efficiently makes it possible to use software tools to find worst-case examples. The situation is essentially different for nested word automata because a minimal deterministic automaton need not be unique [3,5,24] and there is no known efficient minimization algorithm, even for deterministic nested word automata. Basic operations and determinization of visibly pushdown automata (that are essentially similar to nested word automata) have been implemented in [26]. However, the usability of the tools for verifying worst-case state complexity examples is limited due to the lack of an efficient minimization algorithm. In order to get a better quantitative understanding of regular languages of nested words, the study of state complexity of basic regularity preserving operations has been initiated in [18,24]. Here in Section 4 we will summarize the known state complexity results for deterministic and nondeterministic nested word automata. Many questions remain open. In particular, for the deterministic state complexity of concatenation, Kleene star and reversal the known upper and lower bounds remain far apart, and the same holds for the nondeterministic state complexity of complementation. We will discuss general techniques to establish lower bounds for the number of states of a (non)-deterministic nested word automaton. The techniques are inspired by the fooling set methods [7,14,20] used for ordinary nondeterministic finite automata (NFA). We will establish a new lower bound for the state complexity of Kleene star of regular nested word languages that is of a different order than the worst-case state complexity of Kleene star of ordinary DFAs.

2

Finite Automata on Nested Words

We assume that the reader is familiar with with finite automata and state complexity, see [27,29,31]. Here we briefly recall the definitions associated with automata on nested words. More details on nested words and their applications can be found in [4,5]. In the following Σ always denotes a finite alphabet. The tagged alphabet corˆ = Σ ∪ Σ ∪ Σ, where Σ = {a | a ∈ Σ} is the set of responding to Σ is Σ call symbols and Σ = {a | a ∈ Σ} is the set of return symbols. Elements of Σ

State Complexity of Nested Word Automata

61

ˆ are called internal symbols. A tagged word over Σ is a sequence of symbols of Σ, ˆ w = u1 · · · um , ui ∈ Σ, i = 1, ..., m. We define recursively a hierarchical matching relation in a tagged word. For w as above, a call symbol ui ∈ Σ matches a return symbol uj ∈ Σ, i < j, if in the subsequence ui+1 · · · uj−1 every call symbol (respectively, return symbol) has a matching return symbol (respectively, call symbol). Symbol occurrences ui ∈ Σ that do not have a matching return, 1 ≤ i ≤ m, are pending calls, and ui ∈ Σ that does not have a matching call is a pending return. The above conditions define a unique matching relation between the call-symbol occurrences and the return symbol occurrences in any tagged word. By a nested word we mean a tagged word that is associated with the usual linear ordering of symbols and the hierarchical matching relation between occurrences of call and return symbols. The set of nested words over Σ is denoted NW(Σ). A nested word language is any subset of NW(Σ). A nested word is wellmatched if every call symbol has a matching return. An example of a nested word is abacaadcadabab. Here all occurrences of a are linear, the call-symbol c (respectively, d) matches return symbol d (respectively, c), both occurences of b are pending returns and b is a pending call. The word is not well-matched since it has pending calls and/or returns. Language operations such as concatenation, Kleene star and reversal are extended in the natural way for sets of nested words. For example, the catenation of nested words w1 and w2 is the uniquely defined nested word where the underlying tagged word is the catenation of the tagged words corresponding to w1 and w2 . Note that in the catenation pending calls of w1 may match return symbol occurrences in w2 . When reversing a nested word, return symbols become call ˆ symbols and vice versa, for more details see [5]. The number of symbols a ∈ Σ occurring in a nested word w is denoted |w|a . We recall the definition of nested word automata from [5]. This definition explicitly distinguishes the linear states that the computation passes following the linear ordering of the symbols and the hierarchical states that are passed from a call symbol to a matching return symbol. The distinction will be useful for obtaining precise bounds for state complexity. A simplified definition of nested word automata was used in [4]. Definition 1. A nondeterministic nested word automaton, NNWA, is a tuple A = (Σ, Q, Q0 , Qf , P, P0 , Pf , δc , δi , δr ), where Σ is the input alphabet, Q is the finite set of linear states, Q0 ⊆ Q is the set of initial linear states, Qf ⊆ Q is the set of final linear states, P is the finite set of hierarchical states, Q∩P = ∅, P0 ⊆ P is the set of initial hierarchical states, Pf ⊆ P is the set of final hierarchical states, δc : Q × Σ −→ 2Q×P is the call transition function, δi : Q × Σ −→ 2Q is the internal transition function, and δr : Q × P × Σ −→ 2Q is the return transition function. For defining the computations of an NNWA it is convenient to view a nested word u1 · · · um as a directed graph where there is a linear edge from ui to ui+1 , i = 1, . . . , m − 1, and additionally each pair of matching call and return symbols is connected by a hierarchical edge.

62

K. Salomaa

An NNWA A begins a nondeterministic computation in some initial linear state q0 ∈ Q0 . It reads an internal symbol using the internal transition function similarly as an ordinary NFA. When encountering a call symbol a in a linear state q, A sends along the linear edge a state q  ∈ Q and along the hierarchical edge a state p ∈ P where (q  , p ) ∈ δc (q, a) is nondeterministically chosen. When A encounters a return-symbol a in a linear state state q and receives state p ∈ P along the hierarchical edge, the computation continues in some linear state of δr (q, p, a). If a is a pending return, A uses an arbitrary initial hierarchical state p0 ∈ P0 as the second argument for δr . The frontier of a computation of A corresponding to a prefix w1 of the input w is a tuple (p1 , . . . , pk , q), where pi ∈ P , i = 1, . . . , k, k ≥ 0, are the states sent along pending hierarchical edges and q ∈ Q is the linear state reached at the end of w1 . Here pending hierarchical edges refer to call symbols such that the current prefix w1 does not have a matching return. Note that the frontier of the computation completely determines how the computation can be continued on the remainder of the input. The NNWA A accepts a nested word w if in some nondeterministic computation it reaches the end of w in a final linear state and all hierarchical states of the computation corresponding to pending calls are final, that is, the frontier at the end of the computation is of the form (p1 , . . . , pk , q), q ∈ Qf , pi ∈ Pf , i = 1, . . . , k, k ≥ 0. The nested word language recognized by A is denoted L(A). Two NNWAs are said to be equivalent if they recognize the same language. A nested word language is regular if it is recognized by an NNWA. A nested word automaton A as given in Definition 1 is said to be deterministic (a DNWA) if δc (respectively, δi , δr ) is a partial function Q × Σ → Q × P (respectively, Q × Σ → Q, Q × P × Σ → Q). Note that we allow that a DNWA is incomplete, that is, some values of the transition functions may be undefined. Any DNWA as can be “completed”, that is, the transition functions can be made to be total functions by adding at most one linear and one hierarchical state. An extension of the subset construction allows a deterministic simulation of an NNWA. An NNWA is said to be linearly accepting if all hierarchical states are final. A linearly accepting NNWA decides whether or not to accept the input based only on the linear state it reaches at the end of the computation. The following result from [5], see also [4], gives an upper bound for the size blow-up of determinizing an NNWA. The upper bound is tight within a multiplicative constant. Proposition 1. [5] A linearly accepting NNWA with k linear and h hierarchical 2 states can be simulated by a DNWA with 2k·h linear and 2h hierarchical states. There exist languages of nested words Ln , n ≥ 1, recognized by an NNWA with 2 O(n) states such that any DNWA for Ln needs Ω(2n ) states. We define the deterministic (respectively, nondeterministic) state complexity of a regular nested word language L, denoted sc(L) (respectively, nsc(L)), as the smallest total number of states (linear states and hierarchical states) of any DNWA (respectively, NNWA) recognizing L. Naturally, a more complete descriptional complexity measure for nondeterministic automata would include

State Complexity of Nested Word Automata

63

the number of transitions [9,10,17], however, here we do not consider transition complexity of NNWAs. It should be noted that the roles played by the (numbers of) linear and hierarchical states, respectively, are different and often state complexity bounds are formulated separately for the numbers of linear and of hierarchical states. The combined value, sc(L) or nsc(L), is a convenient approximation of the descriptional complexity of L, especially in cases where precise upper and lower bounds are not known.

3

State Complexity Lower Bounds

The closure properties of regular languages of nested words under operations such as concatenation, Kleene star and reversal are established using nondeterministic nested word automata [5]. As indicated by Proposition 1, a DNWA equivalent to an n state NNWA may require more than 2n states and, consequently, it is not clear whether the known upper bounds for the state complexity of basic operations on regular languages [29] hold for languages of nested words. The answer seems to depend on particular properties of each operation. The regularity of nested word languages can be characterized by the finiteness of suitably defined congruence relations that extend the Myhill-Nerode right congruence to nested words, however, the number of congruence classes does not, in general, give the number of states of a minimal DNWA and the minimal DNWA need not be unique [3,5]. Note that [3] deals with visibly pushdown automata (VPA) and a state-minimal VPA corresponds to a DNWA that is minimized only with respect to the number of linear states. However, using essentially the same idea one can construct a nested word language that has two non-isomorphic DNWAs with a minimal total number of states. We can develop lower bound techniques for the number of states of a (non)deterministic nested word automaton that are inspired by the fooling set method useds for NFAs [7,14,20]. In the case of DNWAs, instead of a set of pairs of words we can use a set of nested words where each pair can be separated by a suitably chosen suffix. Definition 2. Let L be a nested word language over Σ. (i) A finite set S ⊆ NW(Σ) is a separator set for L if every element of S is a prefix of some word in L and for any two element set {u, v} ⊆ S, u = v, there exists x ∈ NW(Σ) such that ux ∈ L if and only if vx ∈ L. (ii) A set of pairs of nested words F = {(xi , yi ) | i = 1, . . . , m} is said to be a fooling set for L if: (iia) xi yi ∈ L, i = 1, . . . , m, and (iib) for any 1 ≤ i < j ≤ m, xi yj ∈ L or xj yi ∈ L. The set S is a k-separator set, k ≥ 0, if each word in S has exactly k pending calls. The set F is a k-fooling set, k ≥ 0, if each xi has exactly k pending call symbols.

64

K. Salomaa

Lemma 1. [18,24] Let A be a (deterministic or nondeterministic) nested word automaton with a set of linear states Q and a set of hierarchical states P . (i) If A is a DNWA and S is a k-separator set for L(A) then |P |k · |Q| ≥ |S|. (ii) If L(A) has a k-fooling set F , then |P |k · |Q| ≥ |F |. The use of Lemma 1 is restricted by the requirement that all words corresponding to a k-separator or k-fooling set must have the same number of pending calls. A modified lower bound technique involving additional conditions is used in [24] to establish a tight state complexity lower bound for union and complementation. Already in the case of ordinary regular languages it is known that the lower bounds obtained by the fooling set methods may be far removed from the actual nondeterministic state complexity of the language [16], and the same limitation naturally carries over to NNWAs. It was left open in [24] how good estimates, in the worst case, the k-separator sets provide for the size of DNWAs. To illustrate the use of Lemma 1 we establish a lower bound for the state complexity of Kleene star that is of a different order than the worst-case state complexity of star of ordinary regular languages. (The state complexity of the Kleene star operation for nested word languages was not considered in [24].) It is well known that the state complexity of the Kleene star for DFAs is 2n−1 + 2n−2 [29]. We construct nested word languages that give a lower bound of 2Ω(n·log n) for the state complexity of star. For w ∈ {0, 1}∗ we denote by num(w) the number represented by the binary word w. Note that w may contain leading zeros. Let Σ = {0, 1, a, b} and let n ∈ IN be arbitrary but fixed. We define Ln = {0, 1, a}∗ ∪ Ln

(1)

Ln = {w1 au1 bu2 w2 au3 bw2 bw1 | w1 , w2 ∈ {0, 1}n, ui ∈ {0, 1, a}∗, i ∈ {1, 3}, u2 ∈ {0, 1, a}∗a ∪ {ε}, |u2 |a = num(w1 ) }.

(2)

where

Lemma 2. The state complexity of Ln is O(2n ). Proof. We describe the construction of a DNWA A for the language Ln . Afterwards we describe how the construction can be modified to obtain a DNWA for Ln . The following description assumes that the input for A is of the form z = v1 bv2 bv3 bv4 , vi ∈ {0, 1, a}∗, i = 1, . . . , 4. If this is not the case, A can easily be made to reject without exceeding the bound on the number of states. On an input z, A checks that the prefix of z of length n + 1 is of the form w1 a, w1 ∈ {0, 1}n.

(3)

If the prefix is not of this form, A rejects. When reading the prefix A stores w1 in the linear state, and after this the computation passes by symbols of {0, 1, a} until it reaches a call symbol b. From the call symbol the computation continues

State Complexity of Nested Word Automata

65

in a linear state qw1 and hierarchical state pw1 that both encode the binary string w1 of length n. The linear computation beginning in state qw1 reads symbols of {0, 1, a} and counts num(w1 ) occurrences of a. After the num(w1 )’th occurrence of a, the automaton checks that the following subword is of the form w2 a, w2 ∈ {0, 1}n, and stores w2 in the linear state. The computation passes by symbols of {0, 1, a} until it encounters a b. Now the computation checks that the following n symbols equal w2 and are followed by a return symbol b. Finally, the last stage of the computation verifies that the suffix following b is equal to the word w1 that is encoded by the hierarchical state pw1 received at the return symbol b. The linear computation of A consists of a constant number of phases that each either read a binary word w of length n and store it in the state, or compare w symbol by symbol with some word stored in the state. This can be implemented using O(2n ) linear states. The number of hierarchical states of A is exactly 2n . To conclude construction, we modify A as follows to obtain a DNWA A for the nested word language Ln . If the input consists only of symbols 0, 1, a, the DNWA A is made to accept. This case applies also when the prefix of length n + 1 of the input is not of the form (3). This modification requires that A has to remember whether or not it has seen symbols other than 0, 1, a, and hence it is sufficient to double the number of states. 

Lemma 3. Let Σ = {0, 1, a, b}. For nested word languages Ln ⊆ NW(Σ) as in (1), n sc(L∗n ) ∈ Ω(2n·2 ). Proof. We denote by xi , 1 ≤ i ≤ 2n , the unique word in {0, 1}n such that num(xi ) = i − 1. We denote by F2n the set of functions from {1, . . . , 2n } into {0, 1}n. For f ∈ F2n , we define the nested word vf = x1 ax2 · · · ax2n abf (1)af (2)a · · · af (2n ). Consider an arbitrary y ∈ {0, 1}n. Since all the words xi , i = 1, . . . , 2n , are distinct, it follows that for any xi , 1 ≤ i ≤ 2n , vf bybxi ∈ L∗n iff xi a · · · x2n abf (1)a · · · f (2n )bybxi ∈ Ln iff y = f (i). For verifying the first “iff” statement, recall that the subset of Ln consisting of words containing some call or return symbols is exactly the language Ln (2). Hence wbxi can be in L∗n only if wbxi has a suffix in Ln . From the above it follows that the set S1 = {vf | f ∈ F2n } is a 1-separator set for L∗n . If Q and P are, respectively, the sets of linear and hierarchical states of an arbitrary DNWA B recognizing L∗n , we have by Lemma 1 (i) that n

|Q| · |P | ≥ |S1 | = 2n·2 . n−1

Now the number of states of B is greater than max(|Q|, |P |) ≥ 2n·2

.



66

K. Salomaa

As a consequence of Lemmas 2 and 3 we get: Theorem 1. For arbitrarily large n ∈ IN there exist regular nested word languages Mn such that sc(Mn ) ∈ O(n) and sc(Mn∗ ) ∈ 2Ω(n·log n) . The lower bound of Theorem 1 is greater than the state complexity of Kleene star of ordinary regular languages, however, it is very far from the best known upper bound. Proposition 1 and the upper bound for the nondeterministic state 2 complexity of star [18] give only an upper bound of the form 2c·n (for a suitable constant c) for the state complexity of the star of an n state DNWA language.

4

Summary of State Complexity Results and Open Problems

Deterministic and nondeterministic operational state complexity has been investigated in [24] and [18], respectively, and the known upper and lower bounds are summarized in Table 1. The lower bound for the deterministic state complexity of Kleene star was established in the previous section in Theorem 1. The upper bounds for the deterministic state complexity of Kleene star and reversal and the nondeterministic state complexity of complementation follow from the construction converting an arbitrary NNWA to a DNWA [5]. When the lower and upper bounds do not coincide, in Table 1 the row element for that operation is divided into two parts. In the table, ki , hi , i = 1, 2, refer to the numbers of linear and hierarchical states, respectively, of the DNWAs (or Table 1. Deterministic and nondeterministic state complexity. The entries (†) indicate a tight bound within an additive constant. The lower bound (‡) can be reached by the catenation of L1 and L2 where sc(L1 ) = 2 and sc(L2 ) = n2 . The bound () is tight in terms of the total number of states and max(h1 , h2 ) is a lower bound for the number of hierarchical states. Deterministic s.c. Union Intersection Complement (l.b.) (u.b.)

Nondeterministic s.c.

(4k1 k2 , 4h1 h2 )(†) (k1 + k2 , max(h1 , h2 ) + 2)() (k1 k2 , h1 h2 ) (k1 k2 , h1 h2 ) √ (2k1 , 2h1 )(†) Ω( n1 !) 2 O(2n1 )

Concatenation (l.b.) (u.b.)

2Ω(n2 log n2 ) (‡) 2 O(n1 · 24n2 )

(k1 + k2 , max(h1 , h2 )) (k1 + k2 , h1 + h2 )

Kleene star (l.b.) (u.b.)

2Ω(n1 log n1 ) 2 2O(n1 )

(k1 , h1 ) (4k1 , 4h1 )

Reversal (l.b.) (u.b.)

2Ω(n1 log n1 ) 2 2n1

(k1 , h1 )

State Complexity of Nested Word Automata

67

NNWAs) recognizing the argument languages. The symbols ni , i = 1, 2, refer to the total number of states used by the automata for the argument languages. More specifically, in the deterministic (respectively, nondeterministic) state complexity column of the table, a lower bound (respectively, an upper bound) for a binary operation , (f (k1 , k2 ), g(h1 , h2 )) indicates that for nested word languages Li recognized by a DNWA (resp. NNWA) with ki linear and hi hierarchical states, i = 1, 2, a DNWA (resp. NNWA) for the language L1  L2 needs in the worst-case at least (respectively, at most) f (k1 , k2 ) linear and g(h1 , h2 ) hierarchical states. For a unary operation, k1 and h1 refer, respectively, to the numbers of linear and hierarchical states of the DNWA (resp. NNWA) recognizing the single argument language. For the deterministic state complexity of concatenation, Kleene star and reversal, as well as the nondeterministic state complexity of complementation the bounds are stated simply in terms of the total number of states, where n1 , n2 refer to the deterministic (or nondeterministic) state complexity of the argument languages. For these operations the upper and lower bounds remain far apart and detailed formulas in terms of the numbers of linear and hierarchical states would appear unnecessarily complicated. Table 1 gives tight results (within an additive constant) for union and intersection and for the deterministic state complexity of complement. The results for intersection are perhaps “expected”, that is, they are similar to the case of ordinary regular languages, with the only difference that we need to consider separately the sets of linear and hierarchical states, respectively. The upper bounds for the deterministic state complexity of union and complement involve multiplicative constants that do not appear in corresponding bounds for ordinary regular languages. Intuitively, the constants are needed because in a deterministic nested word automaton recognizing the union of languages recognized by two different automata, the linear state has to remember (a constant amount of) information propagated along the pending hierarchical states. It should be emphasized that this is not simply a feature of a particular construction used to handle union, and the upper bound can be reached at least within an additive constant [24]. When constructing an NNWA to recognize the union of languages recognized by two different automata, the hierarchical states can be reused in both “parts” of the automaton whereas the same property does not hold for the linear states. Thus the roles played by the numbers of linear and hierarchical states in the upper bound for the nondeterministic state complexity of union appear to be different. Again the bound is known to be tight [18]. When considering ordinary regular languages, the worst-case deterministic state complexity of concatenation, Kleene star and reversal is exponential [29] and the same holds for the nondeterministic state complexity of complementation [19,22]. Thus, concatenation, Kleene star and reversal can be viewed as “hard” operations for deterministic automata while complementation is “hard”

68

K. Salomaa

for nondeterministic automata. The results summarized in Table 1 indicate that for each of the “four hard operations” the best known lower bound for nested word automata is of a different order than the worst-case state complexity of the same operation for ordinary regular languages. Concerning the corresponding upper bounds, the bound for concatenation [24] combines ideas of the optimal DFA construction for the concatenation of two DFA languages [29] with the construction that converts an arbitrary NNWA to a DNWA [4,5]. The remaining three upper bounds for the “hard” operations are direct corollaries of Proposition 1 from [5]. Likely the upper bounds could be slightly improved using a detailed analysis. The upper and lower bounds for the “four hard operations” given in Table 1 remain very far apart and, thus, the main open questions on operational state complexity of nested word automata deal with closing the gaps between these bounds. It remains to be seen whether we need stronger lower bound techniques than Lemma 1, or whether up to now we have simply not been able to come up with sufficiently clever worst-case examples. Problem 1. What is the precise deterministic state complexity of concatenation, Kleene star and reversal, and the precise nondeterministic state complexity of complementation of nested word languages. Besides the above mentioned operations, also some other state complexity results in Table 1 are not tight. The upper and lower bound entries for the nondeterministic state complexity of concatenation and Kleene star differ by a multiplicative constant and, as discussed in [18], just by relying on Lemma 1 (ii) it seems difficult to get tight bounds for these operations. As regards nondeterministic state complexity of reversal, differing from the case of ordinary NFAs [19] the result of Table 1 does not need an additional state because the definition of NNWAs allows the use of multiple initial states. In this paper we have concentrated on state complexity of operations on regular nested word languages. Besides closure properties, the regular nested word languages retain many of the nice decidability properties of regular languages. As regards complexity of decision problems, it is shown in [5], for example, that equivalence and inclusion of DNWAs can be decided in polynomial time and that equivalence and inclusion of NNWAs are complete for exponential time. Recall that equivalence and inclusion are PSPACE-complete for NFAs [29]. Since congruence based characterizations seem not sufficient to minimize DNWAs [3,5], minimization becomes a combinatorial question. Minimization of subclasses of visibly pushdown automata (VPA) has been investigated in [8,23]. The computation of a DNWA on a nested word can be viewed as a computation of a deterministic VPA on the underlying tagged word [5], and the minimization problems of DNWAs and VPAs are closely related. It remains open whether general DNWAs can be minimized in polynomial time. On the other hand, there is no known hardness result for the complexity of DNWA minimization.

State Complexity of Nested Word Automata

69

References 1. Alur, R.: Marrying words and trees. In: Proc. of 26th ACM Symposium on Principles of Database Systems, PODS 2007, pp. 233–242 (2007) 2. Alur, R., Arenas, M., Barcel´ o, P., Etessami, K., Immerman, N., Libkin, L.: Firstorder and temporal logics for nested words. In: Proc. of 22nd IEEE Symposium on Logic in Computer Science, pp. 151–160 (2007) 3. Alur, R., Kumar, V., Madhusudan, P., Viswanathan, M.: Congruences for visibly pushdown languages. In: Caires, L., Italiano, G.F., Monteiro, L., Palamidessi, C., Yung, M. (eds.) ICALP 2005. LNCS, vol. 3580, pp. 1102–1114. Springer, Heidelberg (2005) 4. Alur, R., Madhusudan, P.: Adding nesting structure to words. In: H. Ibarra, O., Dang, Z. (eds.) DLT 2006. LNCS, vol. 4036, pp. 1–13. Springer, Heidelberg (2006) 5. Alur, R., Madhusudan, P.: Adding nesting structure to words. Full version of [4], www.cis.upenn.edu/~ alur/Stoc04Dlt06.pdf 6. Arenas, M., Barcel´ o, P., Libkin, L.: Regular languages of nested words: Fixed points, automata, and synchronization. In: Arge, L., Cachin, C., Jurdzi´ nski, T., Tarlecki, A. (eds.) ICALP 2007. LNCS, vol. 4596, pp. 888–900. Springer, Heidelberg (2007) 7. Birget, J.C.: Intersection and union of regular languages and state complexity. Inform. Process. Lett. 43, 185–190 (1992) 8. Chervet, P., Walukiewicz, I.: Minimizing variants of visibly pushdown automata. In: Kuˇcera, L., Kuˇcera, A. (eds.) MFCS 2007. LNCS, vol. 4708, pp. 135–146. Springer, Heidelberg (2007) 9. Domaratzki, M., Salomaa, K.: Lower bounds for the transition complexity of NFAs. J. Comput. System. Sci. 74, 1116–1130 (2008) 10. Domaratzki, M., Salomaa, K.: Transition complexity of language operations. Theoret. Comput. Sci. 387, 147–154 (2007) 11. Gao, Y., Salomaa, K., Yu, S.: The state complexity of two combined operations: Star of catenation and star of reversal. Fund. Inform. 83, 75–89 (2008) 12. Gauwin, O., Niehren, J., Roos, Y.: Streaming tree automata. Inform. Proc. Lett. 109, 13–17 (2008) 13. G´ecseg, F., Steinby, M.: Tree languages. In: [27], vol. III, pp. 1–68 14. Glaister, I., Shallit, J.: A lower bound technique for the size of nondeterministic finite automata. Inform. Process. Lett. 59, 75–77 (1996) 15. Goldstine, J., Kappes, M., Kintala, C.M.R., Leung, H., Malcher, A., Wotschke, D.: Descriptional complexity of machines with limited resources. J. Universal Comput. Sci. 8, 193–234 (2002) 16. Gruber, H., Holzer, M.: Finding lower bounds for nondeterministic state complexity is hard. In: H. Ibarra, O., Dang, Z. (eds.) DLT 2006. LNCS, vol. 4036, pp. 363–374. Springer, Heidelberg (2006) 17. Gruber, H., Holzer, M.: Inapproximability of nondeterministic state and transition complexity assuming P = NP. In: Harju, T., Karhum¨ aki, J., Lepist¨ o, A. (eds.) DLT 2007. LNCS, vol. 4588, pp. 205–216. Springer, Heidelberg (2007) 18. Han, Y.-S., Salomaa, K.: Nondeterministic state complexity of nested word automata (September 2008) (submitted for publication) 19. Holzer, M., Kutrib, M.: Nondeterministic descriptional complexity of regular languages. Internat. J. Foundations of Comput. Sci. 14, 1087–1102 (2003) 20. Hromkoviˇc, J.: Communication Complexity and Parallel Computing. Springer, Heidelberg (1997)

70

K. Salomaa

21. Hromkoviˇc, J.: Descriptional complexity of finite automata: Concepts and open problems. J. Automata, Languages and Combinatorics 7, 519–531 (2002) 22. Jir´ askov´ a, G.: State complexity of some operations on binary regular languages. Theoret. Comput. Sci. 330, 287–298 (2005) 23. Kumar, V., Madhusudan, P., Viswanathan, M.: Minimization, learning, and conformance testing of boolean programs. In: Baier, C., Hermanns, H. (eds.) CONCUR 2006. LNCS, vol. 4137, pp. 203–217. Springer, Heidelberg (2006) 24. Piao, X., Salomaa, K.: Operational state complexity of nested word automata. In: Cˆ ampeanu, C., Pighizzini, G. (eds.) Descriptional Complexity of Formal Systems, DCFS 2008, Charlottetown, Canada, pp. 194–206 (2008) 25. Neumann, A., Seidl, H.: Locating matches of tree patterns in forests. In: Arvind, V., Ramanujam, R. (eds.) FST TCS 1998. LNCS, vol. 1530, pp. 134–146. Springer, Heidelberg (1998) 26. Nguyen, H.: VPAlib: Visibly pushdown automata library (2006), http://www.emn.fr/x-info/hnguyen/vpa 27. Rozenberg, G., Salomaa, A. (eds.): Handbook of Formal Languages, vol. I–III. Springer, Heidelberg (1997) 28. Salomaa, K., Yu, S.: On the state complexity of combined operations and their estimation. Internat. J. Foundations of Comput. Sci. 18, 683–698 (2007) 29. Yu, S.: Regular languages. In: [27], vol. I, pp. 41–110 30. Yu, S.: Grail+: A symbolic computation environment for finite-state machines, regular expressions and finite languages (2002), http://www.csd.uwo.ca/Research/grail 31. Yu, S.: State complexity: Recent results and open problems. Fund. Inform. 64, 471–480 (2005)

A Language-Based Comparison of Extensions of Petri Nets with and without Whole-Place Operations Parosh Aziz Abdulla1 , Giorgio Delzanno2 , and Laurent Van Begin3 1

3

Uppsala University, Sweden [email protected] 2 Universit` a di Genova, Italy [email protected] Universit´e Libre de Bruxelles, Belgium [email protected]

Abstract. We use language theory to study the relative expressiveness of infinite-state models laying in between finite automata and Turing machines. We focus here our attention on well structured transition systems that extend Petri nets. For these models, we study the impact of wholeplace operations like transfers and resets on nets with indistinguishable tokens and with tokens that carry data over an infinite domain. Our measure of expressiveness is defined in terms of the class of languages recognized by a given model using coverability of a configuration as accepting condition.

1

Introduction

The class of well-structured transition systems (wsts) [1] includes several interesting examples of infinite-state models whose expressiveness lay in between that of finite automata and that of Turing machines. Some examples of wsts are Petri nets [1], transfer and reset nets [2], lossy FIFO channel systems (LCS) [3,4], and constrained multiset rewriting systems (CMRS) [5]. Petri nets are a widely used model of concurrent computations. A Petri net is defined by a finite set of places containing multisets of tokens and by a finite set of transitions that define the flow of tokens among places. Each transition first consumes and then produces a fixed number of tokens in each place. Transfer/reset nets extend Petri net with whole-place operations, i.e., transitions that operate simultaneously on all tokens in a given set of places. In a lossy FIFO channel system places are viewed instead as unreliable FIFO channels. Finally, CMRS can be viewed as an extension of Petri nets in which tokens carry natural numbers and transitions are guarded by constraints on data attached to tokens. For all the above mentioned models, the coverability problem is decidable [5,3,4,2]. This decision problem is of great importance for verification of safety properties like mutual exclusion. An interesting research question concerns the study of the relative expressiveness of well-structured models. For this purpose, it comes natural to use tools from language theory to compare the languages generated by labelled transition A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 71–82, 2009. c Springer-Verlag Berlin Heidelberg 2009 

72

P. Aziz Abdulla, G. Delzanno, and L. Van Begin

systems that describe the operational semantics of different models. Unfortunately, a standard notion of acceptance like reachability of a configuration is not adequate to obtain a fine-grained classification of wsts. For instance, with this notion of acceptance transfer/reset nets are equivalent to Turing machines. As shown in [6,7,8], a finer classification of wsts can be obtained by considering the class of languages recognized with coverability acceptance conditions (c-languages for short). A classification of wsts based on c-languages is particularly interesting since it can be used to extend the applicability of a decision procedure for coverability (e.g. the symbolic backward reachability algorithm in [9]) from a particular wsts model to an entire class. In this paper we use c-languages as a formal tool to study the impact of whole-place operations on the expressiveness of Petri nets with black indistinguishable tokens and with tokens that carry data over an ordered domain. For this purpose, we compare the expressiveness of Petri nets, LCS, and CMRS with that of affine well-structured nets (AWNs) [10] and data nets [11]. AWNs are a generalization of Petri nets and transfer/reset nets in which the firing of a transition is split into three steps: subtraction, multiplication, and addition of black tokens. Multiplication is a generalization of transfer and reset arcs. Data nets can be viewed as a generalization of AWNs in which these steps are defined on tokens that carry data taken from an infinite, ordered domain. Conditions on data values can be used here to restrict the type of tokens on which apply whole-place operations. Although presented in a different style, a data net can be viewed as a CMRS enriched with whole-place operations. For the above mentioned models, we prove the following results. We first show that AWNs are strictly more expressive than Petri nets and strictly less expressive than lossy FIFO channel systems. The proof of the second result exploits a non-trivial property of the class of c-languages recognized by AWNs based on Dickson’s lemma [12]. We then show that, differently from nets with indistinguishable tokens, whole-place operations do not augment the expressive power of models in which tokens carry data taken from an ordered domain. The proof is based on a weak, effectively constructible encoding of data nets into CMRS that can be used to reduce the coverability problem from one model to the other. Weakness refers here to the fact that the CMRS encoding simulates a lossy version of data nets, i.e., data nets in which tokens may get lost. However this is enough to show that the two models define the same class of c-languages. Our analysis has several interesting consequences. First, it can be used to give a strict classification of the expressiveness of a large class of wsts models taken from the literature. Furthermore, it shows that the symbolic backward reachability algorithm for solving the CMRS coverability problem given [5] can also be applied in presence of whole-place operations like transfer and reset of colored tokens. Finally, as discussed in the conclusions, our weak encoding of data nets into CMRS can naturally be adapted to extend the decidability of coverability to a more general definition of data nets transition than the one given in [11]. Our extensions include, for instance, generation of fresh values, a feature present in several models of concurrency like CCS and π-calculus.

A Language-Based Comparison of Extensions of Petri Nets

73

Related Work. In [7,8] the authors compare the relative expressiveness of Petri nets with reset, transfer, and non-blocking arcs. A classification of infinite-state systems in terms of decidable properties is presented in [13]. The classification is extended to well-structured systems in [14]. Both classifications do not include models like CMRS and data nets. A classification of the complexity of the decision procedures for coverability of different formulations of data nets is studied in [11]. In [6] we have compared CMRS with lossy FIFO channel systems and other weaker models like relational automata. However, we have not considered whole-place operations like those in AWNs and data nets. We believe that a comparative study of all these sophisticated models can be useful to find new applications of the theory of well-structured transition systems. Preliminary Notions. In this paper we consider extensions of finite automata defined by using labelled transition systems. A transition system T = (S, R) consists of a set S of configurations and of a set R of transitions, where a transiρ →⊆ S × S. A transition system T is said to be well-structured (wsts) with tion − respect to a quasi ordering  on configurations iff the following conditions hold: (i)  is a well-quasi ordering, i.e., for any infinite sequence of configurations γ1 γ2 . . . γi . . . there exist indexes i < j such that γi  γj ; (ii) T is monotonic, ρ ρ i.e., for any −→∈ R, if γ1  γ2 and γ1 −→ γ3 , then there exists γ4 s.t. γ3  γ4 ρ and γ2 −→ γ4 . Given a wsts T , we label each transition in R either with a symbol  from an alphabet Σ or with the empty word  (silent transition). If we associate to a wsts T an initial configuration γ0 and a final configuration γacc , the language recognized by T with coverability acceptance (c-language for short) is defined as follows: w Lc (T ) = {w ∈ Σ ∗ | γ0 =⇒ γ and γacc  γ} w

where γ0 =⇒ γ denotes a finite sequence of application of transitions such that the concatenation of their labels produces the word w. We use Lc (M) to denote the class of c-languages recognized by instances T of a given model M (e.g. Petri nets, transfer nets, etc.), i.e., Lc (M) = {L | ∃S ∈ M, L = Lc (S)}. Given a wsts T = (S, R, ) with labels in Σ ∪ {}, a lossy version of T is a wsts T  = (S, R , ) for which there exists a bijection h : R → R such that ρ

h(ρ)

ρ

h(ρ)

h(ρ)

ρ

− →∈ R and −−−→ have the same label, − →⊆−−−→ and if γ −−−→ γ  , then γ − → γ    with γ  γ . In a lossy version of a wsts, the set of reachable configurations contains configurations that are smaller than those of the original model. The following lemma then holds. Lemma 1. For any lossy version T  of a wsts T , we have that Lc (T ) = Lc (T  ).

2

Whole-Place Operations in Nets with Black Tokens

In this section we use c-languages as a formal tool to compare the expressiveness of Petri nets, affine well-structured nets (AWNs) [10], and lossy FIFO channel

74

P. Aziz Abdulla, G. Delzanno, and L. Van Begin  Ft =

p q 1 0



⎛ Gt = ⎝ p q

p 1 0

⎞ q 0 ⎠ 0

 Ht =

p q 0 1



Fig. 1. An example of AWN transition

systems (LCS) [3,4]. AWNs are a generalization of Petri nets in which transitions admit whole-place operations, i.e., operations that operate simultaneously on the whole set of tokens in a given place. Examples of whole-place operations are reset (all tokens in a place are consumed) and transfer arcs (all tokens in a place are transferred to another place) [2]. Formally, an AWN consists of a finite set P of places and of a finite set T of transitions. As in Petri nets, AWN-configurations, called markings, are vectors in NP , i.e., finite multisets with symbols in P . A marking counts the current number of tokens in a given place in P . In the rest of the paper we use [a1 , . . . , an ] to indicate a multiset with elements a1 , . . . , an . Furthermore, for a marking M , we use M (a) to denote the number of tokens in place a. Finally we use, − and + to denote multiset difference and union. An AWN-transition t is defined by two vectors Ft and Ht in NP , and by a P N × NP -matrix Gt . Intuitively, Ft defines a subtraction step (how many tokens to remove from each place), Gt defines a multiplication step (whole-place operations), and Ht defines an addition step (how many tokens are added to each place). t is enabled at marking M if Ft ≤ M where ≤ denotes marking (multiset) inclusion, i.e., M ≤ M  iff M (p) ≤ M  (p) for each p ∈ P . The firing of t at a marking M amounts to the execution of the three steps in sequence. Formally, it produces a new marking M  = ((M − Ft )·Gt )+ Ht , where · denotes the multiplication of vector (M − Ft ) and matrix Gt . As an example, let P = {p, q} and consider the transition t in Fig. 1. This transition removes a token from p and resets the number of tokens in q to 1. For instance, from the marking M = [p, p, q, q, q], i.e., the vector (2, 3) ∈ NP , we obtain the new marking M  = [p, q] defined by the vector ((2, 3) − (1, 0)) · Gt + (0, 1) = (1 ∗ 1 + 3 ∗ 0, 1 ∗ 0 + 3 ∗ 0) + (0, 1) = (1, 1). As shown in [10], AWN are well-structured with respect to marking inclusion ≤. Petri nets are the subclass of AWNs in which Gt is the identity matrix, i.e., with no whole-place operations. In [7] the authors have shown that there exists a c-language L ∈ Lc (T ransf er nets) such that L ∈ Lc (P etri nets). Since transfer nets are a special case of AWNs, we obtain the following property. Proposition 1. Lc (P etri nets) ⊂ Lc (AW N ). To obtain a sort of upper bound on the expressive power of nets with whole-place operations, we can consider nets in which places maintain some kind of order between their tokens as in lossy FIFO channel systems (LCS). A LCS is a tuple (Q, C, N, δ), where Q is a finite set of control states, C is a finite set of channels, N is a finite set of messages, δ is a finite set of transitions, each of which is of the form (q1 , Op, q2 ) where q1 , q2 ∈ Q, and Op is a mapping from channels to channel operations. For any c ∈ C and a ∈ N , an operation Op(c) is either a send operation !a, a receive operation ?a, the empty test ?, or the null operation nop. A configuration γ is a pair (q, w) where q ∈ Q, and w is a mapping from C to N ∗

A Language-Based Comparison of Extensions of Petri Nets

75

giving the content of each channel. The initial configuration γinit of F is the pair (q0 , ε) where q0 ∈ Q, and ε denotes the mapping that assigns the empty sequence  to each channel. The (strong) transition relation (that defines the semantics of σ machines with perfect FIFO channels) is defined as follows: (q1 , w1 ) −→ (q2 , w2 ) if and only if σ = (q1 , Op, q2 ) ∈ δ such that, for all c ∈ C, if Op(c) =!a, then w2 (c) = w1 (c) · a; if Op(c) =?a, then w1 (c) = a · w2 (c); if Op(c) = ? then w1 (c) =  and w2 (c) = ; if Op(c) = nop, then w2 (c) = w1 (c). Now let l be the well-quasi ordering on LCS configurations defined as: (q1 , w1 ) l (q2 , w2 ) if and only if q1 = q2 and ∀c ∈ C : w1 (c) w w2 (c), where w indicates the subword σ relation. We introduce then the weak transition relation =⇒ that defines the σ  semantics of LCS: we have γ1 =⇒ γ2 iff there exists γ1 and γ2 s.t. γ1 l γ1 , σ σ γ1 −→ γ2 , and γ2 l γ2 . Thus, γ1 =⇒ γ2 means that γ2 is reachable from γ1 by first losing messages from the channels and reaching γ1 , then performing a transition, and, thereafter losing again messages from channels. As shown in [3,4], LCS are well-structured w.r.t. l . The following theorem then holds. Theorem 1. Lc (AW N ) ⊂ Lc (LCS). Proof (1) We first prove the inclusion Lc (AW N ) ⊆ Lc (LCS). Assume an AWN W = (P, T, F, G, H) with P = {p1 , . . . , pn }. We build a LCS F = (Q, C, N, δ) such that Lc (W ) = Lc (F ). W.l.o.g. we assume that channels can be non-empty in the initial configuration of a LCS. The set of channels is defined as C = P ∪P  where P  (auxiliary channels) contains a primed copy of each element in P . The set of messages N contains the symbol • (a representation of a black token). Assume that q0 ∈ Q is the initial state of F . Then, a marking M is encoded as a LCS configuration enc(M ) with state q0 and in which channel pi ∈ P contains the word •mi containing mi = M (pi ) occurrences of symbol • for i ∈ n, and all channels in P  are empty (we define n as [1, . . . , n]). For each transition t with label , we need to simulate the three steps (subtraction, multiplication, and addition) that correspond to Ft , Gt and Ht . Subtraction and addition can be simulated in a straightforward way by removing/adding the necessary number of tokens from/to each channel. The multiplication step is simulated as follows. For each i ∈ n, we first make a copy of the content of channel pi in the auxiliary channel pi . Each copy is defined by repeatedly moving a symbol from pi to pi and terminates when pi becomes empty. When the copy step is terminated, we start the multiplication step. For each i ∈ n, we remove a message • from pi and add as many •’s to channel pj as specified by Gt (pi , pj ) for j ∈ n. This step terminates when the channels p1 , . . . , pn are all empty. For an accepting AWN-marking Mf , the accepting LCS-configuration is enc(Mf ). The following properties then hold: i) We first notice that M ≤ M  iff w w enc(M ) l enc(M  ); ii) Furthermore, if M0 =⇒ M1 in W , then enc(M0 ) =⇒ w enc(M1 ) in F ; iii) Finally, since • symbols may get lost in F , if enc(M0 ) =⇒ w enc(M1 ) then there exists M2 such that M0 =⇒ M2 and M1 ≤ M2 . Since we consider languages with coverability acceptance, Lc (W ) = Lc (F ) immediately follows from properties (i),(ii), (iii) and Lemma 1.

76

P. Aziz Abdulla, G. Delzanno, and L. Van Begin

(2) We prove now that Lc (LCS) ⊆ Lc (AW N ). For this purpose, we exhibit a language in Lc (LCS) and prove that it cannot be recognized by any AWN. Fix a finite alphabet Σ = {a, b, } and let L = {w w | w ∈ {a, b}∗ and w w w}. It is easy to define a LCS that accepts the language L: we first put w in a lossy channel and then remove one-by-one all of its messages. Thus, we have that L ∈ Lc (LCS). We now prove that there is no AWN that accepts L. Suppose it is not the case and there exists a AWN N , with (say) n places, that recognizes L with initial marking Minit and accepting marking Mf . w

w

For each w ∈ {a, b}∗ , there is a marking Mw such that Minit =⇒ Mw =⇒ M and Mf ≤ M (otherwise w w would not be in Lc (N )). Consider the sequences w0 , w1 , w2 , . . . and Mw0 , Mw1 , Mw2 , . . . of words and markings defined as follows: – w0 := bn ; – If Mwi = (m1 , . . . , mn ) then wi+1 := am1 b am2 b · · · b amn , for i = 0, 2, . . . We observe that (a) w0 w wi for all i > 0, since w0 contains n occurrences of b, while wi contains only n−1 occurrences of b; and (b) for any i < j, Mwi ≤ Mwj iff wi+1 w wj+1 . By Dickson’s lemma [12], there are i < j such that Mwi ≤ Mwj . Without loss of generality, we can assume that j is the smallest natural number satisfying this property. Remark that we have that wi w wj . Indeed, w0 w wj for any j > 0 by (a), and in the case of i > 0 we have by (b) that wi w wj since Mwi−1 ≤ Mwj−1 . Since Mwi ≤ Mwj , by monotonicity of AWNs, we have wi wi that Mwi =⇒ M with Mf ≤ M implies that Mwj =⇒ M  with Mf ≤ M ≤ M  . wj wi

Hence, Minit =⇒ M  and wj wi ∈ Lc (N ) = L, which is a contradiction.

 

By combining Prop. 1 and Theorem 1 we obtain the following strict classification. Lc (P etri nets) ⊂ Lc (AW N ) ⊂ Lc (LCS) As a corollary, we have that transfer/reset nets are strictly less expressive than LCSs.

3

Whole-Place Operations in Nets with Colored Tokens

In this section we study the impact of whole-place operations on the expressiveness of well-structured colored Petri nets like CMRS [5] and data nets [11]. CMRS is an extension of Petri nets in which tokens are labelled with natural numbers. For a fixed number of places P , we represent a token in place p with value v as the term p(v). A CMRS configuration is a multiset of ground terms like [p(1), p(3), q(4)] (we recall that markings are multisets over P , i.e., a special case of CMRS configurations). We use P -terms to denote terms associated to colored tokens. CMRS transitions are defined in terms of conditional multiset rewriting rules of the form L ; R : Ψ where L and R are terms with variables that describe colored tokens and Ψ is a condition over such variables. Conditions are expressed by a finite conjunction of constraints in the following form: x + d < y, x ≤ y, x = y, x < d, x > d, x = d where x, y are variables appearing in L and/or

A Language-Based Comparison of Extensions of Petri Nets ⎛

⎞ ⎛ e3 e4 e1  p q p q p q ⎠s = ⎝ p q 5 1 2 10 2 2 29 28 ⎛ ⎞ S1 R1 R0 ⎜ ⎜ p q p q p q ⎠ ⎜ ⎜ R0 p 0 0 1 0 0 0 ⎜ q ⎜ ⎞ Gt = ⎜ p ⎜ S1 R1 R0 ⎜ S1 q ⎜ p q p q p q ⎠ ⎝ p R1 0 0 0 1 0 0 q

e1 s=⎝ p q 3 2 ⎛ Ft = ⎝ ⎛ Ht = ⎝

e2

e2

p q 5 1 R0 p q 1 0 3 1 0 0 2 0 0 0 0 0

e3 p q 25 1 S1 p q 3 0 0 0 1 0 0 0 0 0 0 0

e4

77 ⎞

p q ⎠ 2 2 ⎞ R1 p q ⎟ ⎟ 0 0 ⎟ ⎟ 0 0 ⎟ ⎟ 0 0 ⎟ ⎟ 0 0 ⎟ ⎟ 1 0 ⎠ 0 1

Fig. 2. Two data net markings (s and s ) and a transition t with arity 1

R and d ∈ N is a constant. A rule r is enabled at a configuration c if there exists a valuation of the variables V al (V al(x) ∈ N) such that V al(Ψ ) is satisfied and c ≥ V al(L). Firing r at c leads to a new multi-set c = c − V al(L) + V al(R), where V al(L), resp. V al(R), is the multi-set of ground terms obtained from L, resp. R, by replacing each variable x by V al(x). As an example, consider the CMRS rule: ρ = [p(x) , q(y)]

;

[q(z) , r(x) , r(w)] : {x + 2 < y , x + 4 < z , z < w}

A valuation which satisfies the condition is Val (x) = 1, Val (y) = 4, Val(z) = 8, and Val (w) = 10. Thus, to fire t on c = [p(1), p(3), q(4)] we first remove p(1) and q(4) and then add the new tokens q(8), r(1), and r(1), producing the configuration c = [p(3), q(8), r(1), r(10)]. The coverability problem for CMRS is decidable for an ordering c that extends multi-set inclusion by taking into consideration the relative “gaps” among the values on different tokens [5]. We come back to this point later. It is important to remark that CMRS rules does not provide whole-place operations (the semantics is defined using rewriting applied to sub-multisets of tokens). Despite of it, in [6] we show that colors and gap-order conditions is enough to obtain a model that is strictly more powerful than LCS. By combining this property with Theorem 1, we have that Lc (P etri nets) ⊂ Lc (AW N ) ⊂ Lc (LCS) ⊂ Lc (CM RS) A natural research question now is whether whole-place operations add power to models like CMRS or not. To answer this question, instead of defining a new version of CMRS, we compare its expressiveness with that of data nets [11]. Data nets are an extension of AWNs in which tokens are colored with data taken from a generic infinite domain D equipped with a linear ordering ≺. As discussed in [11], for coverability we can equivalently consider dense or discrete orderings. A data net has a finite sets of places P and transitions T . A data net marking s is a multiset of tokens that carry (linearly ordered) data in D, i.e., s is a finite sequence of vectors in NP \{0}, where 0 is the vector that contains only 0’s. Each

78

P. Aziz Abdulla, G. Delzanno, and L. Van Begin

index i in the sequence s corresponds to some di ∈ D (data values that occur in some token) such that i ≤ j if and only if di ≺ dj ; s(i)(p) is the number of tokens with data di in place p. In Fig. 2 we show two examples of configurations, namely, s and s , for a data net with places P = {p, q}. The data in D that occur in tokens in s and s are e1 ≺ e2 ≺ e3 ≺ e4 . Transitions like that in Fig. 2 are defined by vectors (of vectors) Ft and Ht and by a matrix Gt that define resp. subtraction, addition, and multiplication of colored tokens. Vectors and matrices are indexed by regions defined by the partitioning of the set of tokens R(αt ) = (R0 , S1 , R1 , . . . , Sk , Rk ) associated to the arity αt = k of the rule. The arity is used to select k data values d1 , . . . , dk either fresh or occurring in the current configuration. Region Si is defined as {di }. Regions Ri ’s are used to define whole-place operations (e.g. transfers) for tokens whose data are not in {d1 , . . . , dk }. R0 contains all data d : d ≺ d1 in s, Ri contains all d : di ≺ d ≺ di+1 in s for i : 1, . . . , k − 1, and Rk contains all d : dk ≺ d in s. To illustrate, consider the marking s and the rule t with has arity 1 both defined in Fig. 2. The partitioning is defined here as R(αt ) = {R0 , S1 , R1 }. Let us assume that t (non-deterministically) partitions the data in s as follows R0 = {e1 , e2 }, S1 = {e3 }, and R1 = {e4 }, its firing is defined as follows. Subtraction. Ft specifies the number of tokens with data d1 , . . . , dk that have to be removed, for each place in P , from the current configuration s. t is enabled if places have enough tokens to remove. In our example p contains two tokens with value e3 , and Ft specifies that one token with value e3 must be removed. Thus, t is enabled in s. The subtraction step produces an intermediate configurations s1 obtained from s by removing one token with data e3 from place p. Multiplication. Gt specifies whole-place operations on the regions in R(αt ). In our example the third column of Gt defines the effect of multiplication on the number of tokens with data e3 in place p in s1 . Specifically, we add to the tokens in place p with value e3 (1 in position S1 , p, S1 , p in Gt ), three new tokens with value e3 for each token with value in R0 that lay into place p in s1 (3 in position R0 , p, S1 , p in Gt ). Thus, the total number of tokens with value e3 in p becomes (3 + 5) ∗ 3 + 1 = 25. Furthermore, since the fourth column has only zeroes, all tokens with data e3 are removed from place q (a reset restricted to all tokens with value e3 in q). The first column of Gt defines the effect on the tokens with values in R0 in place p. Specifically, for each d ∈ R0 , we add to place p three tokens with value d for each token with the same value laying into q in s1 (3 in position R0 , q, R0 , p in Gt ); two tokens with data d for each token with data e3 in q (2 in position S1 , q, R0 , p in Gt ). Thus, the total number of tokens with value e1 in p is now 3 + 3 ∗ 2 + 2 ∗ 10 = 29 and that for value e2 in p is now 5 + 3 ∗ 1 + 2 ∗ 10 = 28. The other columns of Gt leave the same tokens as those in the corresponding regions and places in s1 . We use s2 to refer to the resulting intermediate configuration. Addition. Ht specifies the number of tokens that are added, for each place, region, and data to the configuration s2 to obtain the successor configuration s .

A Language-Based Comparison of Extensions of Petri Nets

79

In our example, we simply add one token with data e3 to place q. Finally, the new configuration s is given in Fig. 2. It is important to remark that whole-place operations are uniformly applied to each data value in a region. Whole-place operations between region Ri and Rj as well as subtractions from a region Ri are forbidden. Furthermore, in case of whole-place operations from Ri to Sj (or vice versa) tokens may change data value (e.g. all tokens with data d ∈ Ri in p are moved to place q with value dj ), whereas in operations within a single region Ri tokens do not change data value. As proved in [11], data nets are well-structured with respect to the well-quasi ordering d defined on markings as follows. Let Data(s) be the set of data values that occur in a marking s. Then, s1 d s2 iff there exists an injective function h : Data(s1 ) → Data(s2 ) such that (i) h is monotonic and (ii) s1 (d)(p) ≤ s2 (h(d))(p) for each d ∈ Data(s1 ) and p ∈ P . In other words we compose subword ordering (condition (i)) with multiset inclusion (condition (ii)). 3.1

CMRS, Petri Data Nets, and Data Nets

Data nets without whole place operations (i.e. in which Gt is the identity matrix) are called Petri data nets. Petri data nets defined on a domain with a single data value d are equivalent to Petri nets. Furthermore, as discussed in [11], it is possible to effectively build an encoding of CMRS into Petri data nets such that coverability in CMRS can be reduced to coverability into Petri data nets. Indeed, the well-quasi ordering c used in CMRS is basically the same as that used in Data nets (the only technical difference is due to the presence of constants in conditions of CMRS rules). Thus, we have that Lc (CM RS) = Lc (P etri data nets) ⊆ Lc (Data nets) We show next that the inclusion is not strict, and that Petri data nets, CMRS, and data nets have all the same expressive power. To prove this result, we have to show that for each Data nets D we can effectively build a Petri data net or a CMRS S such that Lc (S) = Lc (D). Since CMRS rules have a format similar to a (logic) programming language, we find more convenient to describe the encoding in CMRS. Configurations. Given a multi-set M with symbols in P and a value or variable x, we use M x to denote the multi set of P -terms such that M x (p(x)) = M (p) (=number of occurrences of p in M ) for each p ∈ P , and M x (p(y)) = 0 for any y = x and p ∈ P . Now assume an initial data net marking s0 with data d1 ≺ . . . ≺ dn . We build a CMRS representation of s0 by non-deterministically selecting n natural numbers v1 < . . . < vn strictly included in some interval [f, l]. P -terms with parameter vi represent tokens with data di in place p. Formally, we generate the representation of s0 by adding to S a rule that rewrites an initial zero-ary term init as follows

[init] ; [f irst(f ), last(l)] + i:1,...,n Mixi : f < x1 < . . . < xn < l (init)

80

P. Aziz Abdulla, G. Delzanno, and L. Van Begin

Here Mi is the multiset s0 (di ) for each i ∈ n. The non-determinism in the choice of f, l, x1 , . . . , xn makes the CMRS representation of s0 independent from specific parameters assumed by terms. Transitions are encoded by CMRS rules that operate on the values in [f, l] used in the representation of a marking. Most of the CMRS rule are based on left-to-right traversals of P -terms with parameters in [f, l]. Consider a transition t with αt = k. We first define a (silent) CMRS-rule that implements the subtraction step of t: [f irst(f ), last(l)] + Ft (S1 )x1 + . . . + Ft (Sk )xk ; (subtract) [ı0 (f ), ı1 (x1 ), ...., ık (xk ), ık+1 (l), newt ] : f < x1 < ... < xk < l Here newt is a nullary predicate (with no data) that indicates the action to be performed next. In the subtract rule we non-deterministically associate a value, represented by variable xi in the above defined rule, to region Si . The selection is performed by removing (from the current configuration) the multiset Ft (Si )xi that contains Ft (Si , p) occurrences of p(xi ) for each p ∈ P . The association between value xi and region Si is maintained by storing xi in a ıi -term (introduced in the right-hand side of the rule). If Ft (Si , p) = 0 for any p ∈ P , then a value xi may be associated to a data di not occurring in the current marking (i.e. selection of fresh data is a special case). Furthermore, by removing both the f irst- and the last-term, we disable the firing of rules that encode other data net transitions. The values x1 , . . . , xk stored in ı1 -,. . . ,ık -terms play the role of pointers to the regions S1 , . . . , Sk . We refer to them as to the set of αt -indexes. The parameters of terms in [f, l] associated to the other regions R0 , . . . , Rk are called region-indexes. To simulate the multiplication step we proceed as follows. We first make a copy of the multiset of P -terms with parameters v1 , . . . , vn in [f, l] by copying each p-term with parameter vi in a p-term with parameter wi such that f  < w1 < . . . < wn < l and [f  , l ] is an interval to the right of [f, l], i.e., l < f  . The newt -term in the subtract rule is used to enable a set of (silent) CMRS rules (omitted for brevity) that create the copy-configuration. During the copy we add a -term for any visited region index. These terms are used to remember region indexes whose corresponding P -terms are all removed in the multiplication step (e.g. when all tokens with data d ∈ Ri are removed). For instance, [p(v1 ), p(v2 ), p(v2 ), q(v3 )] with f < v1 < v2 < v3 < l is copied as [p(w1 ), (w1 ), p(w2 ), p(w2 ), (w2 ), q(w3 )(w3 )] for some w1 , w2 , w3 such that f < l < f  < w1 < w2 < w3 < l . The copy process is implemented by a left-to-right scan of the values that represent data. The scan uses a predicate as a pointer to the current value to consider. The pointer is moved to the right by non-deterministically jumping to a larger value (CMRS conditions cannot specify the “next” value). Thus, during the traversal we may forget to copy some token. This is the first type of loss we find in our encoding. Notice that lost tokens have parameters strictly smaller that f  . The simulation of the multiplication step operates on the copy-configuration only (with P -terms only). The intuition behind its definition is as follows. We first consider all αt -indexes of P -terms from left to right. For each αt -index vi ,

A Language-Based Comparison of Extensions of Petri Nets

81

we proceed as follows. We first select and remove a term p(vi ) (encoding a given token). We compute then the effect of the whole-place operation on the entire set of αt -indexes (including vi itself). More specifically, for an αt -index vj we add Gt (Si , p, Sj , q) occurrences of the term q(vj ) to the current CMRS configuration. The use of P - and P -terms with parameters in the same interval allows us to keep track of tokens still to transfer (P -terms) and tokens already transferred (P -terms). We then consider all remaining indexes by means of a left-to-right traversal of region-indexes in the current configuration. During the traversal, we add new P -terms with region-indexes as parameters as specified by Gt . During this step, we may forget to transfer some P -term. This is the second type of loss we find in the encoding. After this step we either consider the next token with αt -index vi or we move to the next αt -index. After the termination of the whole-place operations for terms with αt -indexes, we have to simulate the transfer of P -terms with region-indexes. For each such an index, we transfer tokens within the same region-index or to an αt -index. To simulate these operations we scan region-indexes from left-to-right to apply the matrix Gt . Furthermore, we mark visited region-indexes using -terms. The -terms are used in the simulation of the addition step. As a last step we add tokens to αt -indexes and visited region-indexes as specified by Ht . For αt -indexes, we need a single rule that applies the matrix Ht . For region-indexes, we traverse from left-to-right the current configuration and apply Ht to each marked (with a -term) region-index w. As mentioned before, the -term allows us to apply Ht to regions emptied by the multiplication step. All the rules are silent except the last rule used to encode addition whose label is the same as that of t. During the traversal, we may ignore some (marked) region-index. This is the last type of loss in our encoding. The new configuration is the final result of the simulation of the transition. Due to the possible losses in the different simulation steps, we may get a representation of a data net configuration smaller than the real successor configuration. To formalize the relation between a data net D and its CMRS encoding E(D), for a configuration s with data d1 ≺ . . . ≺ dk we use sv to denote the CMRS representation with indexes v = (v1 , . . . , vk ). For configurations s0 , s1 , s, we have w w that (i) if s0 =⇒ s1 in D, then there exists v such that [init] =⇒ s1 v in E(D). w Furthermore, (ii) if [init] =⇒ c in E(D) and sv c c for some v, then there exists w s1 such that s0 =⇒ s1 in D with s d s1 . Finally, suppose that the accepting data net marking is a sequence M1 . . . Mk of k vectors (multi-sets) over NP . Then, we add a silent CMRS rule  [f irst(f ), last(l)] + Mixi ; [acc] : f < x1 < x2 < . . . < xk < l, x = 0 i∈{1,...,k}

where acc is a fresh (with arity zero) predicate. By adding this rule, the accepting CMRS configuration can be defined as the singleton [acc]. From properties (i), (ii) and Lemma 1, we have the following result. Theorem 2. Lc (Data nets) = Lc (CM RS).

82

4

P. Aziz Abdulla, G. Delzanno, and L. Van Begin

Conclusions

By combining the results in the present paper with the relation between LCS and CMRS describe in [6], we obtain the following classification of well-structured extensions of Petri nets Lc (P etri nets) ⊂ Lc (AW N ) ⊂ Lc (LCS) ⊂ Lc (CM RS) = Lc (Data nets) This classification reveals a different impact of whole-place operations on nets with black and colored tokens: they augment the expressive power of basic models like Petri nets, but they can be simulated in extended models in which tokens carry ordered data. We believe that our analysis can also be applied to extend the scope of the decidability results given in [11] to more general well-structured systems obtained by relaxing some of the constraints in the definition of data nets transitions. We plan to explore this research direction in future work.

References 1. Finkel, A., Schnoebelen, P.: Well-structured transition systems everywhere! TCS 256(1-2), 63–92 (2001) 2. Dufourd, C., Finkel, A., Schnoebelen, P.: Reset nets between decidability and undecidability. In: Larsen, K.G., Skyum, S., Winskel, G. (eds.) ICALP 1998. LNCS, vol. 1443, pp. 103–115. Springer, Heidelberg (1998) 3. Abdulla, P.A., Jonsson, B.: Verifying programs with unreliable channels. Information and Computation 127(2), 91–101 (1996) 4. C´ec´e, G., Finkel, A., Iyer, S.P.: Unreliable channels are easier to verify than perfect channels. Information and Computation 124(1), 20–31 (1996) 5. Abdulla, P.A., Delzanno, G.: On the coverability problem for constrained multiset rewriting. In: Proc. AVIS 2006, an ETAPS 2006 workshop (2006) 6. Abdulla, P.A., Delzanno, G., Van Begin, L.: Comparing the expressive power of well-structured transition systems. In: Duparc, J., Henzinger, T.A. (eds.) CSL 2007. LNCS, vol. 4646, pp. 99–114. Springer, Heidelberg (2007) 7. Finkel, A., Geeraerts, G., Raskin, J.F., Van Begin, L.: On the ω-language expressive power of extended petri nets. TCS 356, 374–386 (2006) 8. Geeraerts, G., Raskin, J.F., Van Begin, L.: Well-structured languages. Acta Informatica 44(3-4), 249–288 (2007) ˇ ans, K., Jonsson, B., Tsay, Y.K.: General decidability theorems 9. Abdulla, P.A., Cer¯ for infinite-state systems. In: Proc. LICS 1996, pp. 313–321 (1996) 10. Finkel, A., McKenzie, P., Picaronny, C.: A well-structured framework for analysing petri net extensions. Information and Computation 195(1-2), 1–29 (2004) 11. Lazi´c, R.S., Newcomb, T., Ouaknine, J., Roscoe, A.W., Worrell, J.B.: Nets with tokens which carry data. In: Kleijn, J., Yakovlev, A. (eds.) ICATPN 2007. LNCS, vol. 4546, pp. 301–320. Springer, Heidelberg (2007) 12. Dickson, L.E.: Finiteness of the odd perfect and primitive abundant numbers with n distinct prime factors. Amer. J. Math. 35, 413–422 (1913) 13. Henzinger, T.A., Majumdar, R., Raskin, J.F.: A classification of symbolic transition systems. ACM Trans. Comput. Log. 44(1), 1–32 (2005) 14. Bertrand, N., Schnoebelen, P.: A short visit to the sts hierarchy. ENTCS 154(3), 59–69 (2006)

Minimal Union-Free Decompositions of Regular Languages Sergey Afonin and Denis Golomazov Lomonosov Moscow State University, Institute of Mechanics, Moscow, Russia [email protected]

Abstract. A regular language is called union-free if it can be represented by a regular expression that does not contain the union operation. Every regular language can be represented as a finite union of union-free languages (the so-called union-free decomposition), but such decomposition is not necessarily unique. We call the number of components in the minimal union-free decomposition of a regular language the union width of the regular language. In this paper we prove that the union width of any regular language can be effectively computed and we present an algorithm for constructing a corresponding decomposition. We also study some properties of union-free languages and introduce a new algorithm for checking whether a regular language is union-free.

1

Introduction

Regular expressions are a natural formalism for the representation of regular languages. It is well known that there exist regular languages that can be represented by infinitely many equivalent regular expressions, and a number of “canonical” forms of regular expressions representing a given regular language have been proposed in the literature, such as concatenative decomposition [1, 2] and union-free decomposition (see e.g. [3]). This paper is devoted to the task of finding a minimal union-free decomposition of a regular language. A language is called union-free if it can be represented by a regular expression without the usage of the union operation. For example, the language represented by the expression (a + b∗ )∗ is union-free because there exists an equivalent expression (a∗ b∗ )∗ . Union-free languages have been introduced under the name “star-dot regular” languages by J. Brzozowski in [4]. Every regular expression r can be transformed into a regular expression r in which union operations appear only on the “top level” of the expression, i.e., it takes the following form: r = r1 + . . . + rm , and the regular expressions r1 , . . . , rm do not contain the “+” operator (see [3]). This means that every regular language can be represented as a finite union of union-free languages. But this decomposition is not necessarily unique: for example, (a + b)∗ = (a∗ b∗ )∗ = {ε} + a∗ ba∗ + b∗ ab∗ , and these are two different union-free decompositions of the language (a + b)∗ . We 

The research presented in this paper was partially supported by the RFBR grant number 09-01-00822-a.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 83–92, 2009. c Springer-Verlag Berlin Heidelberg 2009 

84

S. Afonin and D. Golomazov

call the minimal number of components in such a representation the union width of the regular language and a corresponding decomposition (that is not necessarily unique) is called a minimal union-free decomposition of a regular language. In this paper we present an algorithm that computes the union width and constructs a minimal union-free decomposition of a regular language. The union width of a regular language and corresponding decompositions may be considered as canonical representations of a regular expression, as well as a complexity measure of a regular language [5], similar to the restricted star height. Union-free decompositions play an important role in the algorithm for checking membership of a regular language in a rational subset of a finitely generated semigroup of regular languages with respect to concatenation as a semigroup product. In order to check such membership one should verify that at least one of the distance automata corresponding to the components of an arbitrary unionfree decomposition of a certain regular language is limited. We do not go into the details here (see [6]). We will just mention that checking the limitedness property is Pspace-complete [7], thus, the number of components in a union-free decomposition is an important parameter influencing membership-checking complexity. The problem of constructing union-free decompositions of regular languages has also practical applications. In particular, regular languages can be used for a description of the syntactic structure of a programming language [8]. The concatenation operation corresponds to the sequential continuation, the Kleene star corresponds to loops, and the union operation corresponds to branching. In this context, union-free languages represent sequences of operators that do not contain conditional transitions. Minimal union-free decompositions of regular languages may be useful for simplifying and normalizing such descriptions. The main result of the current paper is that the union width of a regular language L can be effectively computed, and we present an algorithm that constructs the corresponding decomposition. This result is achieved by using the combinatorial technique we have adopted from [2]. First we take the set C(L) of all maximum finite concatenations of letters and certain star languages derived from the automaton of L. We prove that C(L) is a finite set and that for every union-free decomposition of L there exists a union-free decomposition of L of the same number of elements that consists of languages from C(L). Consequently, there exists a minimal union-free decomposition that consists of languages from C(L). Thus we can obtain it by examining all the subsets of the finite set C(L). We also present an algorithm for checking whether a given regular language is union-free. This decidability result is already known (see Theorem 1 below) but it is based on reduction to the computationally expensive problem of checking limitedness of distance automata, which is Pspace-complete. The paper has the following structure: Section 2 provides some basic definitions, Section 3 presents results concerning general properties of union-free languages, Section 4 is devoted to the algorithm for finding a minimal union-free decomposition of a regular language, and Section 5 contains conclusions and ideas for the further work.

Minimal Union-Free Decompositions of Regular Languages

2

85

Preliminaries

Let Σ = {a1 , . . . , an } be a finite alphabet, L ⊆ Σ ∗ be a regular language and V = Σ, Q, q0 , F, ϕ be the corresponding minimal deterministic finite automaton, where Q = {q1 , . . . , qm } is the set of all states of V , q0 ∈ Q is the initial state, F ⊆ Q is the set of final states and ϕ : Q × Σ → Q is the transition function of the automaton. Let M ⊆ Σ ∗ , q1 ∈ Q. The definition of the function ϕ is extended as follows: ϕ(q1 , M ) = {q ∈ Q | ∃ α = α1 α2 · · · αp ∈ M : ϕ(· · · ϕ(ϕ(q1 , α1 ), α2 ), . . . , αp ) = q}. An ordered list of states {q1 ,. . . ,qm } (qi ∈ Q) is called a path marked with a word w ∈ Σ ∗ iff w = a1 · · · am−1 and ϕ(qi , ai ) = qi+1 , i = 1, . . . , m − 1. A path in an automaton is called cycle-free iff it starts at the initial state q0 , ends at a final state qf ∈ F and does not contain any cycles, i.e., there is no state occurring in the list more than once. It should be noted that by “a cycle-free path in a language” we actually mean a word in the language that is represented by a cycle-free path in the minimal automaton associated with the language. A language W ⊆ Σ ∗ is called a star language iff W = V ∗ for some V ⊆ ∗ Σ . A language L is called union-free iff it can be represented by a regular expression that contains the star and concatenation operations only, i.e., it takes the following form: ∗ ∗ ∗ ∗ ∗ ∗ ∗ S02 · · · S0k u S ∗ · · · S1k u · · · Sl−1,1 · · · Sl−1,k u S ∗ · · · Sl,k , L = S01 0 1 11 1 2 l−1 l l,1 l

(1)

where Sij are regular languages, u1 , . . . , ul are non-empty words, and l  0. We call (1) a general form of a union-free language and denote it GF (L). Let L be a union-free language. We denote tsw(L) the shortest word in L. Proposition 1 shows that the definition is correct, i.e., there cannot exist two different words of minimum length. Definition 1. Let L be a regular language. Then a representation L = L1 ∪L2 ∪ · · · ∪ Lk is called a union-free decomposition of L iff Li is a union-free language for all i = 1, . . . , k. The decomposition is called minimal iff there is no other union-free decomposition of L with fewer elements. Theorem 1 (K. Hashiguchi [9]). Let L be a regular language, T ⊆ {·, ∪, ∗ } be a subset of the rational language operations (concatenation, union, and star), and M = {M1 , . . . , Mn } be a finite set of regular languages. Then it is decidable whether L can be constructed from elements of M using a finite number of operations from T . As an immediate corollary we obtain that it is decidable whether a regular language L is union-free, by taking singleton languages as M and T = {·, ∗ }. Let B be a subset of the set of states Q of the automaton V = Σ, Q, q0 , F, ϕ. The set of words {x ∈ Σ ∗ | ∀q ∈ B, ϕ(q, x) ∈ B} is denoted str(B). Lemma 1 (J.A. Brzozowski, R. Cohen [2]). Let B ⊆ Q. Then str(B) is a regular star language.

86

S. Afonin and D. Golomazov

3

Union-Free Languages

In this section some common properties of union-free languages are studied. In particular, we present an algorithm for checking whether a regular language is union-free. First, we adduce an example of a union-free language. Its associated finite automaton is shown in Fig. 1(a). We believe that it is not a simple task to recognize a union-free language by looking at the automaton. For example, the well-known Kleene algorithm constructs a regular expression that contains three union operations on the top level. The language can be represented as M = S1∗ bS2∗ aS3∗ where S1 , S2 , and S3 are shown in Fig. 1(b),1(c), and 1(d), respectively (the initial states of these automata are marked by 1). In this section we assume that Σ = {a1 , . . . , an } is a finite alphabet, L ⊆ Σ ∗ is a regular language and V = Σ, Q, q0 , F, ϕ is its associated deterministic finite automaton. Proposition 1. Let L be a union-free language. Then tsw(L) is meaningfully defined, i.e., if u and v are shortest words in L then u = v. Proof. Suppose u = u1 · · · ul , v = v1 · · · vl . Consider GF (L). It should have the following form: ∗ ∗ ∗ ∗ ∗ ∗ ∗ S02 · · · S0k u S ∗ · · · S1k u · · · Sl−1,1 · · · Sl−1,k u S ∗ · · · Sl,k . L = S01 0 1 11 1 2 l−1 l l,1 l

Since v ∈ L and length of v is equal to that of u, vi = ui for i = 1, . . . , l, hence u = v. 

a

5

b

b

b

a a b

2

a 1

a

b

a

a

3

b

2

b

3 a

b

1

4

a

b

b

a 4

(b) S1

(a) M

a a a

1

b

b

a

1

b

2 a

a

(c) S2

b

a 3

b b

3

5

4

2 5 a

a b b

6

(d) S3

Fig. 1. Example of the union-free language M = S1∗ bS2∗ aS3∗

b b a

4

Minimal Union-Free Decompositions of Regular Languages

87

Remark 1. Obviously, the word u1 · · · ul in the general form of a union-free language L is equal to tsw(L). Definition 2. Let 2Q = {B1 , . . . , Bk }. We denote B(L) = {str(B1 ), . . . , str(Bk )}. By Lemma 1, B(L) is the finite set of regular star languages that can be constructed for every regular language. We now show that for every representation of a subset of L as a product of a prefix language, a star language and a suffix language the star language can be replaced with a language from B(L). Thus we can extend every subset of L by replacing all star languages within it with star languages from the fixed set B(L). Lemma 2. Let M ⊆ L. Then for every representation M = P R∗ T there exists a language D ∈ B(L) so that M ⊆ P DT ⊆ L. Proof. First it should be noted that we do not consider the automaton associated with M and work only within the automaton for L. Given a representation M = P R∗ T we define G = {q ∈ Q | ∃ w ∈ P, ϕ(q0 , w) = q}.  = {q ∈ Q | ∀w ∈ T ϕ(q, w) ∈ F }. Obviously, G ⊆ G  ⊆ Q. Then we denote G ∗  Taking any words p ∈ P and r ∈ R , we obtain that We define D = str(G).   because ϕ(prt) ∈ F for all t ∈ T . This ϕ(q0 , p) ∈ G ⊆ G and ϕ(q0 , pr) ∈ G,   r ∈ R∗ . Hence, R∗ ⊆ D ∈ B(L) and means that ϕ(q, r) ∈ G for all q ∈ G, M ⊆ P DT . P DT ⊆ L, because we extend the language R∗ to the language D working within the same unmodified automaton for L and therefore cannot obtain a language that contains more words than L does. 

Corollary 1. For every representation L = P R∗ T there exists a language D ∈ B(L) so that L = P DT . Proof. We consider M = L and apply Lemma 2. Then L ⊆ P DT ⊆ L hence L = P DT . 

Definition 3. We denote C(L) a set of all maximal finite concatenations of languages from B(L) and letters such that every concatenation is a subset of L. Maximal means that if C1 , C2 are such finite concatenations and C2 ⊆ C1 then we include only the language C1 in C(L). Lemma 3. Let M ⊆ L, B1 ⊆ Q, B2 ⊆ Q and M = P str(B1 ) str(B2 )T , where P and T are regular languages. Then ϕ(q0 , P str(B1 )) ⊂ ϕ(q0 , P str(B1 ) str(B2 )) or there exists B3 ⊆ Q such that M ⊆ P str(B3 )T ⊆ L. Proof. We denote three sets of states: D1 = ϕ(q0 , P ), D2 = ϕ(q0 , P str(B1 )), and D3 = ϕ(q0 , P str(B1 ) str(B2 )). Since str(B1 ) and str(B2 ) contain the empty word, D1 ⊆ D2 ⊆ D3 . We also obtain that str(B1 ) ⊆ str(D2 ), because the

88

S. Afonin and D. Golomazov

set ϕ(q0 , P str(B1 ) str(B1 )) = ϕ(q0 , P str(B1 )) = D2 . Suppose D2 = D3 . This means that str(B2 ) ⊆ str(D2 ). Therefore, str(B1 ) str(B2 ) ⊆ str(D2 ) and M = P str(B1 ) str(B2 )T ⊆ P str(D2 )T . Finally, we take B3 = D2 . P str(B3 )T ⊆ L because we have not modified the automaton for L and still work within it.

 Lemma 4. C(L) is a finite set. Proof. Every element in C(L) is a concatenation of star languages and letters. As already mentioned, all the letters concatenated form the shortest word in the language represented by the concatenation. First we limit the number of letters in every concatenation by |Q| − 1. We do that as follows: if a concatenation Li ∈ C(L) contains more than |Q| − 1 letters, we show that there is a language Mi ∈ C(L) such that Li ⊆ Mi , and we come to a contradiction with the definition of C(L). We show how to effectively construct the language Mi given the language Li . Suppose Li ∈ C(L) and its general form contains more than |Q| − 1 letters. This means that tsw(Li ) contains cycles in the automaton for L. Then tsw(Li ) = u1 v1 · · · uh vh , where uj ∈ Σ ∗ , vj ∈ Σ + and every vj = vj1 · · · vjlj (j = 1, . . . , h) represents a cycle in the path u1 v1 · · · uh vh in the minimal automaton for L (and every uj does not contain any cycles). This means that Li = Lu1 Lv1 · · · Luh Lvh where languages Luj and Lvj are parts of the general form of Li corresponding to the words uj , vj , respectively. For example, Lv1 = v11 Sp1 · · · Spkp v12 Sp+1,1 · · · Sp+1,kp+1 v13 · · · v1l1 . Then we define the language Mi as Mi = Lu1 (Lv1 )∗ · · · Luh (Lvh )∗ . First, Li ⊂ Mi . Second, tsw(Mi ) = u1 · · · uh and u1 · · · uh represents a cycle-free path in L. Third, Mi ⊆ L, because it has been constructed within the automaton for L. This means that Li ⊂ Mi ⊆ L and we come to a contradiction, since C(L) contains only maximal languages. Now we prove that there is only a limited number of star languages between every pair of adjacent letters in every concatenation M ∈ C(L). For every representation M = P str(B1 ) · · · str(Bk )T we apply Lemma 3 and obtain that either ϕ(q0 , P str(B1 )) ⊂ ϕ(q0 , P str(B2 )) ⊂ . . . ⊂ ϕ(q0 , P str(Bk )) or we can replace the language M with the language M  such that M ⊆ M  and M  = P str(D1 ) · · · str(Dl )T and ϕ(q0 , P str(D1 )) ⊂ ϕ(q0 , P str(D2 )) ⊂ . . . ⊂ ϕ(q0 , P str(Dl )). In this case M ∈ / C(L). We conclude that every element in C(L) can be written as a concatenation with not more than |Q| − 1 star languages between every pair of adjacent letters. These two limitations complete the proof. 

Corollary 2. Let M ∈ C(L). Then tsw(M ) represents a cycle-free path in the automaton associated with L. Proof. Since M ⊆ L, tsw(M ) ∈ L. Suppose tsw(M ) contains cycles in the automaton associated with L. Then applying the procedure described in the proof of Lemma 4 (which constructs the language Mi using the language Li ), we obtain a language M  ∈ C(L) such that M ⊂ M  . This means that M ∈ / C(L) and we get a contradiction. 

Minimal Union-Free Decompositions of Regular Languages

89

|Q|−1  Corollary 3. |C(L)|  c|Q| 2|Q| , where c is the number of cycle-free paths in the automaton associated with L. Proof. First, we fix a cycle-free path in the automaton associated with L (c possibilities). Then we fix a position of star languages: since there are not more than |Q| − 1 letters, we have |Q| possibilities (because star languages can appear before the first letter and after the last one). Then we choose not more than |Q|−1 languages from B(L) (every language can appear more than once), having  |Q| |Q|−1 2 possibilities. Finally, we multiply all three expressions and come to the statement of the corollary. 

Remark 2. In order to construct C(L) given a language L, we simply take all possible concatenations that contain letters that being concatenated form cycle-free paths in the automaton for L and that contain not more than |Q| − 1 languages from B(L) between every pair of letters. Finally, we exclude the languages that are not subsets of L and the languages that are subsets of other languages from the set. Lemma 5. Let L be a regular language and M ⊆ L be a union-free language. Then there exists a language CM ∈ C(L) such that M ⊆ CM . ∗ Proof. We take every star language Si,j from the general form of M . Thus M = ∗ P Si,j T where ∗ ∗ ∗ ∗ · · · S0k a · · · Si1 · · · Si,j−1 P = S01 0 1 ∗ ∗ ∗ ∗ and T = Si,j+1 · · · Si,ki ai+1 · · · al Sl,1 Sl,2 · · · Sl,k . Then we apply Lemma 2 and l derive that M ⊆ P str(Bk )T where Bk ∈ B(L). Thus we extended the “un∗ known” language Si,j to the known language str(Bk ) from the set B(L). After applying the procedure of extension to each star language in the general form for M , we get a language CM that is a finite concatenation of languages from B(L) and letters and also an extension of M . Hence M ⊆ CM and CM ∈ C(L). 

Theorem 2. Let L be a regular language. Then L is a union-free language iff L ∈ C(L). Proof Necessity. We consider M = L and apply Lemma 5. Then there exists a language CL ∈ C(L) such that L ⊆ CL . But since all languages from C(L) are subsets of L, L = CL and hence L ∈ C(L). Sufficiency. Suppose L ∈ C(L) and L is a non-union-free language. Then it cannot be represented as a finite concatenation from C(L) because every concatenation from C(L) only consists of union-free languages (languages from B(L) and letters), and we come to a contradiction. 

4

Union-Free Decomposition

Theorem 3. Let L be a regular language. Then there exists an algorithm that results in a minimal union-free decomposition of L: L = L1 ∪ L2 ∪ · · · ∪ Lk (the algorithm is described within the proof ).

90

S. Afonin and D. Golomazov

Proof. To construct a minimal union-free decomposition, we examine all the subsets of C(L) and choose the subset containing a minimum number of languages (among all the subsets) which being added up are equal to L. It should be noted that there is at least one subset containing languages which being added up are equal to L, because there exists at least one union-free decomposition of L and to every component of the decomposition we can apply Lemma 5, thus obtaining a decomposition of L into languages from C(L). The final step is to prove that the decomposition obtained is minimal, i.e., there exists no decomposition containing fewer elements than the one we got. Suppose we have such a decomposition L = N1 ∪N2 ∪· · ·∪Np , p < k. We take each language Ni (i = 1, . . . , p) and apply Lemma 5 to it, getting a union-free language CNi ∈ C(L) such that Ni ⊆ CNi . Thus we get the new decomposition L = CN1 ∪ CN2 ∪ · · · ∪ CNp , p < k and every language CNi belongs to the set C(L). But since we have already examined all the subsets of C(L), we have examined the subset {CN1 , . . . , CNp } too, and we must have chosen this subset for the minimal decomposition. This contradiction completes the proof. 

Unfortunately, the algorithm for constructing a minimal union-free decomposition of a given regular language L is computationally expensive since it requires |Q|−1  checking all the subsets of the set C(L), which can contain up to c|Q| 2|Q| elements, where c is the number of cycle-free paths in the automaton associated with L (see Corollary 3). We believe that there exist more effective algorithms that result in a minimal union-free decomposition of a given regular language. Some ideas on creating such an algorithm are given below. A promising way of constructing minimal union-free decompositions can be developed using the technique of cutting maximum star languages introduced in [2]. In short, the technique is as follows. Let L be a regular language. The equation L = X ∗ L is proved to have the unique maximal solution X0 (w.r.t. inclusion). Moreover, the equation L = X0∗ Y is proved to have the unique minimal solution Y0 . To construct a minimal union-free decomposition of L we solve these two equations and obtain the language Y0 . Then we apply the same procedure to the language Y0 and get the minimal language Y1 such that L = X0∗ X1∗ Y1 . If the process ends (and it is an open problem, see [10]) we either obtain the language ∗ ) or get a Ym = {ε} (and thus the union-free decomposition L = X0∗ X1∗ · · · Xm ∗ language Ym such that the equation Ym = X Ym has no non-trivial solutions. In the latter case we check whether all the words in the language Ym start with the same letter. If it is the case and, for example, all the words in Ym start ∗ with a, we write Ym = aYm , L = X0∗ X1∗ · · · Xm aYm and apply the procedure  described above to the language Ym (solve the equation Ym = X ∗ Ym etc.). If it is not, and there are words in Ym that start with different letters, e.g. a1 , . . . , an , we can write Ym = Ym1 ∪ · · · ∪ Ymn so that every language Ym1 , . . . , Ymn contains only words starting with the same letter ai , 1  i  n. Then we write ∗ ∗ ∗ L = X0∗ X1∗ · · · Xm Ym1 ∪ X0∗ X1∗ · · · Xm Ym2 ∪ · · · ∪ X0∗ X1∗ · · · Xm Ymn and apply the procedure described above to every language Ym1 , . . . , Ymn . If the process ends, thus we obtain the union-free decomposition of the language L, which is likely to be minimal, but this is yet to be proved. As already mentioned, an-

Minimal Union-Free Decompositions of Regular Languages

91

other open problem connected with this technique is that the described process of “cutting stars” has not yet been proved to always be finite (see [10]).

5

Conclusions and Further Work

In this paper we have presented an algorithm for constructing a minimal unionfree decomposition of a regular language. The algorithm includes an exhaustive search but we tend to think that there exist more effective algorithms that solve the problem. We have also studied some common properties of union-free languages. In particular, we have presented the new algorithm for checking whether a given language is union-free which can be more effective than the one existing in the field (see [9, 7]). There are some other interesting questions connected with the problems considered. For instance, whether languages that form a minimal union-free decomposition are pairwise disjoint (as sets of words). If it is not always the case, one can consider minimal union-free decompositions that consist of pairwise disjoint languages and ways of constructing them. Another open problem is connected with star height. Given a star height of a regular language is it possible to construct a minimal union-free decomposition that consists of languages of the same star height? Acknowledgements. The authors would like to thank the anonymous reviewers for valuable comments. The first author would also like to thank Benedek Nagy for drawing attention to the problem.

References 1. Paz, A., Peleg, B.: On concatenative decompositions of regular events. IEEE Transactions on Computers 17(3), 229–237 (1968) 2. Brzozowski, J., Cohen, R.: On decompositions of regular events. Journal of the ACM 16(1), 132–144 (1969) 3. Nagy, B.: A normal form for regular expressions. In: Eighth International Conference on Developments in Language Theory, CDMTCS Technical Report 252, CDMTCS, Auckland, pp. 51–60 (2004) 4. Brzozowski, J.: Regular expression techniques for sequential circuits. PhD thesis, Princeton University, Princeton, New Jersey (1962) 5. Ehrenfeucht, A., Zeiger, P.: Complexity measures for regular expressions. In: STOC 1974: Proceedings of the Sixth Annual ACM Symposium on Theory of Computing, pp. 75–79. ACM, New York (1974) 6. Afonin, S., Khazova, E.: Membership and finiteness problems for rational sets of regular languages. International Journal of Foundations of Computer Science 17(3), 493–506 (2006) 7. Leung, H., Podolskiy, V.: The limitedness problem on distance automata: Hashiguchi’s method revisited. Theoretical Computer Science 310(1–3), 147–158 (2004)

92

S. Afonin and D. Golomazov

8. Nagy, B.: Programnyelvek elemeinek szintaktikus lersa norml formban (syntactic description of the elements of the programming languages in a normal form). In: IF 2005, Conference on Informatics in Higher Education, Debrecen (2005) 9. Hashiguchi, K.: Representation theorems on regular languages. Journal of Computer and System Sciences 27, 101–115 (1983) 10. Brzozowski, J.: Open problems about regular languages. In: Book, R.V. (ed.) Formal Language Theory, Santa Barbara, CA, Univ. of CA at Santa Barbara, pp. 23–47. Academic Press, New York (1980) 11. Nagy, B.: Union-free languages and 1-cycle-free-path-automata. Publicationes Mathematicae Debrecen 68, 183–197 (2006)

Commutative Regular Shuffle Closed Languages, Noetherian Property, and Learning Theory Yohji Akama Mathematical Institute, Tohoku University, Sendai Miyagi, Japan, 980-8578 (Japan Science and Technology Agency) [email protected]

Abstract. To develop computational learning theory of commutative regular shuffle closed languages, we study finite elasticity for classes of (semi)group-like structures. One is the class of ANd + F such that A is a matrix of size e × d with nonnegative integer entries and F consists of at most k number of e-dimensional nonnegative integer vectors, and another is the class Xkd of AZd + F such that A is a square matrix of size d with integer entries and F consists of at most k number of ddimensional integer vectors (F is repeated according to the lattice AZd ). Each class turns out to be the elementwise unions of k-copies of a more manageable class. So we formulate “learning time” of a class and then study in general setting how much “learning time” is increased by the elementwise union, by using Ramsey number. We also point out that such a standpoint can be generalized by using Noetherian spaces.

1

Introduction

For words u, v on an alphabet Σ, the shuffle product of u and v is, by definition, u  v = { w : ∃n ≥ 1∃u1 , u2 , . . . , un , v1 , v2 , . . . , vn ∈ Σ ∗ w = u1 v1 u2 v2 ...un vn , u = u1 u2 · · · un and v = v1 v2 · · · vn } A language L is said to be shuffle closed if it is closed under shuffle product. L is said to be commutative if xuvy ∈ L ⇐⇒ xvuy ∈ L for all u, v, x, y ∈ Σ ∗ . Let N be {0, 1, 2, . . .}. Parikh mapping is Ψ : Σ ∗ → N#Σ such that Ψ (w) = (n1 , . . . , nr ) where ni is the number of occurrences of si in w. Ψ (L) is the set of Ψ (w) such that w ∈ L. According to [1], for every commutative regular shuffle closed language L, Ψ (L) ⊆ N#Σ is a semigroup 1 , and if L moreover contains the empty word , then n  (1) L = Ψ −1 ( Ai N#Σ + fi ) i=1

for some n ∈ N, some square matrices Ai ’s of size #Σ with nonnegative integer entries and some #Σ-dimensional nonnegative integer vectors fi ’s. Thus computational learning theory for commutative regular shuffle closed languages is 1

In this paper, semigroups are always understood commutative.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 93–104, 2009. c Springer-Verlag Berlin Heidelberg 2009 

94

Y. Akama

related to that for semigroups, and conditions where the learnabilities of each of two classes C1 , C2 implies that of their elementwise union  C2 := {L1 ∪ L2 ; L1 ∈ C1 , L2 ∈ C2 }. C1 ∪ A typical learning process of semigroups is as follows: “Teacher” chooses a positive integer m and presents all the elements of a semigroup m := {nm ; n = 0, 1, 2, 3, . . .} one by one to “Learner”, where “Learner” submits a hypothesis for m whenever he receives a number from “Teacher.” If the hypotheses h1 , h2 , . . . converge to m, then we say that “Learner” learns m. But for each updating of hypothesis, “Learner” cannot know whether his hypothesis is true or not. If “Learner” always submits a hypothesis which respect all the numbers presented so far, then he learns m because an ascending chain h1 ⊆ h2 ⊆ · · · is eventually stationary (i.e. ht = ht+1 = · · · for some t). In other words, “Learner” can learn m because of Noetherian property and the “learning time” t = #{i ; hi−1 = hi } is bounded by the length of a strictly ascending chain from m . However Noetherian property [2,3] for semigroups, which is defined after Noetherian property for semigroup-rings, happens to be unsatisfactory from computational learning viewpoint, because it is satisfied by a semigroup (N2 , +) which turns out to have an infinite strictly ascending chain of subgroups in N2 . In computational learning theory, a property similar to Noetherian property was independently introduced as a sufficient condition for a class of languages to be learnable [4]. The property is called a finite elasticity. The computational learning theory for Noetherian rings and similar algebraic structures are developed by Ventsov and Stephan [5]. We develop learning theory for algebraic structures and language classes by taking following proposition seriously: Proposition 1 (Motoki-Shinohara-Wright [4]). If two classes C1 , C2 of sets  C2 . have finite elasticities, so does C1 ∪ By using the Proposition, the finite elasticity was proved for the class of extended pattern languages (e.g. {ww ; w ∈ Σ ∗ } is an extended pattern language), and the same property will be proved for the class of commutative regular shuffle closed languages in this paper. Also we study finite elasticity for classes of (semi)grouplike structures, such as a class Latticed of d-dimensional integer lattices and a class (2) Xkd := {M + F ; M ∈ Latticed, F ⊆ Zd , #F ≤ k} (k ≥ 1) of integer crystalline structures (F is repeated by a lattice M like a physical crystalline material). The former class Latticed is studied from viewpoint of another computational learning setting [6]. The latter class Xkd is a subclass of the elementwise union of k-copies of more manageable classes. So we formulate “learning time” and then evaluate from upward the “learning time” of the elementwise union in terms of those of the constituents classes, by using Ramsey number R(l, m, 2). We also point out that such a standpoint can be generalized by using Noetherian spaces.

Comm. Regular Sh-Closed Languages, Noetherian Properties and Learning

2

95

Commutative Regular Shuffle Closed Languages

For α, β, p ∈ Nr , we write α ≥ β if each component of α is not less than the → corresponding component of β, and we write α = β (mod p) if α ≥ β but each component of α is congruent to the corresponding component of β modulo the corresponding component of p. Proposition 2 ([1, Proposition 5.3.4, 5.3.5]). Let L ⊆ Σ ∗ such that L contains the empty word . Then L is a commutative regular shuffle closed language if and only if L is represented as ∗     ∗  (3) Ψ −1 Ψ u aδ1u1 p1 · · · aδrur pr L= u∈F

where 1. Y = {a1 , . . . , ar } is an r-size subset of Σ for some positive integer r, F is a finite language over Y with  ∈ F , and δu = (δu1 , . . . , δur ) belongs to {0, 1}r for any u ∈ F . Moreover, 2. p = (p1 , . . . , pr ) belongs to {1, 2, . . . .}r , (a) there exists q ∈ Nr such that for all u ∈ F q ≥ p and q ≥ Ψ (u), and → (b) for any u, v ∈ F , there is w ∈ F such that δu , δv ≤ δw and Ψ (uv) = Ψ (w) (mod (δw1 p1 , . . . , δwr pr )). For the class of commutative regular shuffle closed languages with the shuffle base being finite, the characterization is similar  but δu ’s are always (1, . . . , 1). Here shuffle base of L is defined as (L \ {}) \ (L \ {})  (L \ {}) . By above proposition, every commutative regular shuffle closed language is written as (1), while every commutative regular shuffle closed languages with finite shuffle base is written as Ψ −1 (AN#Σ + F ) for some square matrix A of size #Σ with nonnegative integer entries and for some finite set F ⊂ N#Σ . Here ‘+’ stands for Minkowski sum(i.e., elementwise addition). Definition 1. For any positive integer k, let CRS k be the class of commutative regular shuffle closed languages L such that L   and #F of (3) is less than or equal to k. Let f CRS k be the class of L ∈ CRS k such that the shuffle base of L is finite.

3

Computational Learning Theory: Finite Elasticity and Wright’s Theorems

In this section, we review finite elasticity, a sufficient condition for a class to be learnable, formulate the “learning time,” and then evaluate how much “learning time” is increased by elementwise union by using Ramsey numbers. First of all, we review one of basic settings of computational learning theory. An indexed family of recursive language(i.f.r.l.) is any C = {Li ; i ∈ N} such that there is a computable function f : N × Σ ∗ → {0, 1} where f (i, w) = 1 if

96

Y. Akama

Li  w and f (i, w) = 0 otherwise. We say that this i is a representative of Li or i explains Li . For example, a class {L(G) ; G is a regular grammar} and the  class {nm ; n ∈ N ; m ∈ N are indexed families of recursive languages. We say that an i.f.r.l. C is learnable from positive data by an algorithm A if for any L ∈ C and for any enumeration x1 , x2 , . . . of L, the algorithm A computes a hypothesis hn for L on each initial segment x1 , . . . , xn (n ≥ 1) and the hypotheses h1 , h2 , . . . tends to a representative of L in the limit of n. An algorithm said to be consistent, if Lhn ⊇ {x1 , . . . , xn } for every n. The number of mind-changes taken by A with respect to the presentation x1 , x2 , . . . is defined as #{i ; hi−1 = hi }. The maximum over L and the presentations of L is called the mind-change complexity of C by A, and the maximum over any consistent algorithm that learns C is called the mind-change complexity for C. For example, let us consider the case where “Teacher” teaches “Learner” multiples but “Teacher” always begins with presenting a number x1 less than n as an example of a multiple, while “Learner” always submits a hypothesis consistent with numbers presented so far. Then the hypotheses h1 , h2 , . . . submitted by “Learner” are such that each hi divides hi+1 , so the number of the mind-change taken by “Learner” is at most log2 n. By a similar reasoning, the mind-change complexity of {m ∩ [0, n] ; m ∈ N} is at most log2 n. “Learner” is said to be consistent, if every hypothesis “Learner” submits is consistent with data presented so far. Let N∗ = {0 < 1 < 2 < · · · < n < · · · < ∗}. Definition 2 (finite elasticity, dimension). an elasticity of length α ∈ N∗ , if

We say a class C of sets has

∃{Ln ∈ C ; 1 ≤ n < α} ∃{tγ ; 0 ≤ γ < α} ∀β. 1 ≤ β < α ⇒ {tγ ; 0 ≤ γ < β} ⊆ Lβ  tβ . We say C has an infinite elasticity, if α = ∗. Otherwise, we say C has a finite elasticity. When and only when C has finite elasticity, we define the dimension dim(C) ∈ N ∪ {∞} as the supremum of α such that C has an elasticity of length α < ∗, that is, 

∃{Ln ∈ C ; 1 ≤ n < α} ∃{tγ ; 0 ≤ γ < α} . dim(C) := sup α ; ∀β. 1 ≤ β < α ⇒ {tγ ; 0 ≤ γ < β} ⊆ Lβ  tβ Remark 1. If C has a finite elasticity, then for any pair of “Teacher” and “Consistent Learner,” in a following game between them, the “Consistent Learner” always wins after submitting at most dim(C) numbers of elements of C. In the course of the game, the “Teacher” presents a datum w while the “Consistent Learner” chooses from C an element L that contains the data presented so far. “Teacher” tries to present a datum that the “Consistent Learner” can no more choose such an element from C. “Consistent Learner” wins if the “Teacher” can no more present such a datum. We can easily see that C has a finite elasticity if “Consistent Learner” can always win.

Comm. Regular Sh-Closed Languages, Noetherian Properties and Learning

97

“Teacher” t0 t1 t2 · · · tα−1 “Consistent Learner” L1 L2 · · · Lα−1 Clearly, if C has a finite elasticity then so does any subclass of C. Proposition 3 ([4]). For every i.f.r.l. C, if C has a finite elasticity, it is learnable from positive data. Theorem 1. For any i.f.r.l. C, if dim(C) < ∞, then C is learnable from positive data by a consistent learning algorithm and the mind-change complexity of C is bounded from above by dim(C).  D) from a Ramsey-type proof of Now let us derive an upper bound of dim(C ∪ Proposition 1. First recall Ramsey numbers. Proposition 4 ([7, Section 4.2]). For every l, m ∈ Z≥1 there exists k such that any edge-coloring with red and black for the complete graph of size k has either a red complete subgraph of size l or a black complete subgraph of size m. Such minimum k, denoted by R(l, m, 2),

is called a Ramsey number of l, m, and m+l−2 is bounded from above by ≤ c4max(l,m) (max(l, m))−1/2 for some l−1 constant c. Theorem 2. For any classes C and D, if dim(C) and dim(D) are finite, then  D) < dim(C) · dim(D) · R(dim(C) + 1, dim(D) + 1, 2). dim(C ∪ Proof. Suppose there are a sequence t0 , . . . , tn−1 , a sequence L1 , . . . , Ln−1 of C and a sequence M1 , . . . , Mn−1 of D such that {t0 , . . . , ti−1 } ⊆ Li ∪ Mi  ti

(1 ≤ ∀i < n).

(4)

We have only to show that n < dim(C) · dim(D) · R(dim(C) + 1, dim(D) + 1, 2). It is easy to see: Fact 1 1. Lν1 = · · · = Lνk (1 ≤ ν1 < · · · < νk < n) ⇒ k ≤ dim(D). 2. Mν1 = · · · = Mνk (1 ≤ ν1 < · · · < νk < n) ⇒ k ≤ dim(C). Proof. The first assertion is proved as follows: By (4), {tν1 , . . . , tνi−1 } \ Lνi ⊆ Mνi  tνi

(2 ≤ ∀i ≤ k).

The leftmost term {tν1 , . . . , tνi−1 } \ Lνi is just {tν1 , . . . , tνi−1 }. Otherwise there is a positive integer j less than i such that tνj ∈ Lνi = Lνj , which contradicts (4). The situation is illustrated as a following game between “Teacher” and “Consistent Learner”: “Teacher” tν1 tν2 · · · tνk−1 tνk . “Consistent Learner” Mν2 ··· Mνk Therefore k ≤ dim(D). The second assertion is proved similarly as the first assertion. Fact 2. If Li (i = 1, . . . , n − 1) is pairwise distinct and Mi (i = 1, . . . , n − 1) is pairwise distinct, then n < R(dim(C) + 1, dim(D) + 1, 2).

98

Y. Akama

Proof. Consider a complete graph G with the vertices being 0, . . . , n − 1. For any edge {i, j}(i = j), color it by red if 0 ≤ i < j ≤ n − 1 and ti ∈ Lj , while color it by black otherwise. Assume n ≥ R(dim(C) + 1, dim(D) + 1, 2). By Ramsey’s theorem, the colored complete graph G has either a red clique of size dim(C) + 1 or a black clique of size dim(D) + 1. When a red clique of size dim(C) + 1 exists, write it as {u0 < · · · < udim(C) }. Then we have {tu0 , . . . , tui } ⊆ Lui+1  tui+1 (0 ≤ ∀i < dim(C)), which contradicts the definition of dim(C). Otherwise, a black clique of size dim(D)+1 exists, so we write it as {u0 < · · · < udim(D) }. Then we have {tu0 , . . . , tui } ∩ Lui+1 = ∅ (0 ≤ ∀i < dim(D)). Because (ui )i is in ascending order and (4) holds, we have {tu0 , . . . , tui } ⊆ Lui+1 ∪Mui+1  tui+1 , so {tu0 , . . . , tui } ⊆ Mui+1  tui+1 (0 ≤ i < dim(D)), which contradicts the definition of dim(D). This completes the proof of Fact 2. By the previous Fact 1, in the sequence (4), each Li occurs at most dim(D) times and each Mi occurs at most dim(C) times, so we have the desired consequence of Theorem 2.

4

Finite Elasticity of Semigroups, Commutative Regular Shuffle Closed Languages and Pattern Languages

In this section we give an elementary proof of the finite elasticity of CRS k of Definition 1 and that of extended pattern languages, by considering Parikh mapping and the class of finite generated semigroups of Ne . A monoid (N2 , +) does not have any infinite strictly ascending chain of submonoideals, by Dickson’s Lemma. As a semigroup, (N2 , +) is Noetherian in a following sense: Proposition 5 ([2],[3]). For every semigroup S, following two conditions are equivalent: (a) S is finitely generated. (b) The lattice of congruences on S satisfies ascending chain condition with respect to inclusion. I.e., any ascending chain of congruences on S with respect to inclusion is eventually stationary. S is said to be Noetherian if one of the two conditions (a) or (b) holds. But (N2 , +) has an infinite strictly ascending chain of sub-semigroups. Theorem 3

 1. For any positive irrational r, Mr := t (x, y)∈N2 ; y < rx is a sub-semigroup of (N2 , +) but not finitely generated. 2. A semigroup (N2 , +) has an infinite strictly ascending chain of finitely generated free sub-semigroups.

Proof



1. Assume Mr is finitely generated. Then it becomes (i)

some positive integer n and some kj

(1)

(1)

k1 · · · kn (2) (2) k1 · · · kn

 Nn for

∈ N (i = 1, 2; j = 1, . . . , n). So

Comm. Regular Sh-Closed Languages, Noetherian Properties and Learning

99

for any t (x, y) ∈ Mr with x = 0, y/x is less than or equal to the q := (2) (1) max1≤j≤n,k(1) =0 kj /kj ∈ N. But because r is irrational, there exist two j

positive integers x and y such that q < y/x < r, and (x, y) ∈ Mr . Contradiction. 2. Mr is written as an infinite set {ai }i ⊂ N2 and has an ascending chain of subsemigroups S1 ⊆ S2 ⊆ S3 ⊆ · · · where Si := a0 , a1 , . . . , ai (i = 1, 2, 3, . . .). If Sn = Sn+1 = Sn+2 = · · · , then M becomes Sn which is finitely generated. This contradicts the first assertion of the theorem.   (1) (1) k1 · · · kn We can easily construct a series of matrices An = such that (2) (2) k1 · · · kn An Nn  An+1 Nn+1 from a continued fraction of an irrational number. However if the number of columns(i.e., the number of generators) is bounded, then there is no infinite strictly ascending chain of sub-semigroups of (N2 , +), as we see below. Theorem 4. For all positive integers e and d, SLe,d := {ANd ; A ∈ Me,d (N)}

(Nd := Nd−1 × {1})

has a finite elasticity. Proof. Assume that the set has an infinite elasticity, that is, ∃A1 , A2 , . . . ∈ Me,d (N). ∃w0 , w1 , . . . ∈ Ne . ∀n ≥ 1.{w0 , . . . , wn−1 } ⊆ An Nd  wn .

(5)

For positive integers i, j and any matrix A and vector w, let (A)i,j be the i-th row j-th column component and (w)i be the i-th component. Clearly ∀n ≥ 1. (An )1,d ≤ (w 0 )1

(6)

We will derive a contradiction by induction on d. If d = 1, then An Nd is a singleton for every n, so w0 = w1 = · · · , which contradicts (5). Consider the case where d > 1. A matrix obtained from A ∈ Me,d (N) by removing the j-th column is denoted by j (A) ∈ Me,d−1 (N).   Fact 3. ∀k ∈ N∃ν(k) > k∃j(k) ∈ [1, d−1]. {w0 , . . . , wk } ⊂ j(k) Aν(k) Nd−1 .  (∵) Let m(k) := max (w l )i ; 0 ≤ l ≤ k, 1 ≤ i ≤ e + 1. Then there is n > (m(k))d×e such that ∃i ∈ [1, e]∃j ∈ [1, d]. m(k) ≤ (An )i, j .

(7)

Otherwise there are at most (m(k))d×e number of An which components are all less than m(k). But {A1 , A2 , A3 , . . .} is infinite, a contradiction. We can easily see that there are infinitely many n such that (7) holds.

100

Y. Akama

But by (6) and the definition of m(k), we have j ≤ d − 1. Let us choose  d×e  an n such that (7) and n > max m(k) , k , and denote it by ν(k) >  d×e  max m(k) ,k . For any l ∈ [0, k], if wl is Aν(k) u for some u ∈ Nd with (u)j = 0, then by (7) and the definition of m(k), we have (w l )i ≥ (Aν(k) )i, j > (w l )i , a contradiction. So (u)j = 0. This completes the proof of Fact 3. Then we have a following contradiction to the induction hypothesis. Fact 4. There are an infinite series of e-dimensional vectors wν i (0) (i ≥ 0) and    n−1 an infinite series of e × (d − 1) integer matrices j ν (0) Aν n(0) (n ≥ 1) which     n−1 cause an infinite elasticity: w0 , . . . , wν n−1 (0) ⊆ j ν (0) Aν n (0) Nd−1  wν n (0) . (n ≥ 1).  (∵) For n ≥ 1, because ν(x) > x and (5), we have w0 , . . . , wν n−1 (0) ⊆      n−1 Aν n (0) Nd  wν n (0) . By Fact 3, w0 , . . . , wν n−1 (0) ⊆ j ν (0) Aν n (0) Nd−1 .    n−1 On the other hand, because j ν (0) Aν n (0) Nd−1 ⊆ Aν n (0) Nd , we have   j ν n−1 (0) Aν n (0) Nd−1  w ν n (0) . This completes the proof of Fact 4. Now let us return to the proof of the theorem. By induction hypothesis, SLe,d−1 has a finite elasticity, which contradicts Fact 4. So SLe,d has a finite elasticity. Q.E.D. Recall that CRS k is the class of commutative regular shuffle closed languages L such that L   and #F of (3) is less than or equal to k. Corollary 1. For any positive integer k, CRS k has a finite elasticity. Proof. For any subclass C of the powerset of N#Σ , let Ψ −1 (C) be {Ψ −1 (L) ; L ∈ C}. Then CRS 1 = Ψ −1 (SL#Σ,#Σ+1 ). By the previous theorem, CRS 1 has a finite elasticity, because w ∈ L ⇐⇒ Ψ (w) ∈ Ψ (L) for any L ∈ Ψ −1 (C). So the elementwise union of k-copies of CRS 1 has a finite elasticity by Proposition 1, and contains CRS k . This prove the corollary. The class SL1,v+1 of Theorem 4 is also important in establishing the finite elasticity of extended pattern languages.  Definition 3. The extended pattern language of a pattern p ∈ P atvΣ := Σ ∪ ∗ {x1 , . . . , xv } is the set eLangΣ (p) of σ(p) with σ being any homomorphism from P atvΣ to Σ ∗ such that σ(s) = s for every s ∈ Σ. Then EPAT vΣ is defined as the class of eLangΣ (p) such that p ∈ P atvΣ . For every p ∈ P atvΣ , the set of length of w’s in eLangΣ (p) belongs to SL1,v+1 , because pn induces a matrix An ∈ M1,v+1 (N) such that (An )1,v+1 is the number of occurrences of non-variable symbols in pn while (An )1,j the number of occurrences of xj in pn .

Comm. Regular Sh-Closed Languages, Noetherian Properties and Learning

101

Theorem 5 (Wright[8]). For any v ∈ N, EPAT vΣ has a finite elasticity. Proof. By induction on v ≥ 0. We derive a contradiction from an assumption ∃p1 , p2 , . . . ∈ P atdΣ ∃u0 , u1 , . . . ∈ Σ ∗ ∀n ≥ 1.{u0 , . . . , un−1 } ⊆ eLangΣ (pn )  un . We can prove that 3’ ∀k ∈ N ∃ν(k)  0 , . . . , uk } ⊆ eLangΣ (p ν(k) [xj(k) := ]).  > k ∃j(k) ∈ [1, , d]. {u that 4’ There are uν i (0) i≥0 ⊆ Σ ∗ and pν n (0) [xj(ν n−1 (0)) := ] n≥1 ⊆ P atd−1 Σ cause an infinite elasticity. In this way, we can derive contradiction against the inductive hypothesis. Proposition 6 ([9]). Let #Σ ≥ 2. Then  eLangΣ (x1v x1 x2 x2 x3 x3 )∞does not have := tell-tale set with respect to EPAT ∞ Σ v≥0 EPAT Σ , so EPAT Σ is not learnable by Angluin [10]. Thus EPAT ∞ has an infinite elasticity. Σ Interestingly, the class of finitely generated sub-semigroup of (N, +) has a finite elasticity.  Theorem 6. For all positive integers e and d, ANd \{0} ; A ∈ Me,d (N), d ≥ 1 has a finite elasticity if and only if e = 1. Proof. (If part) Assume the contrary. Then, there are infinite sequences {di ∈ N ; i > 0}, {Ai ∈ M1,di (N) ; i > 0} and {wi ∈ N ; i ≥ 0} such that each Ai Ndi \ {0} contains w0 , . . . , wi−1 but not w i . The free semigroup generated by w0 , w1 , . . . will be written as w0 , w1 , . . . . We observe that   ∀k > 0 ∀w > 0 ∃l > k. w0 , . . . , wk ⊆ Al Ndl  wl and wl > w . (8) Consider a quotient set Q obtained from w0 , . . . , wk ⊂ N by the congruence modulo w0 . Then the cardinality of the quotient set is c(k) := # {i ∈ [0, w0 ) ∩ N ; (Nw0 + i) ∩ w0 , . . . , wk = ∅} . Let {u1 , . . . , uc(k) } = {min q ; q ∈ Q}. By (8) with k being a and w being c(k) max1≤j≤c(k) uj , we have for any j, uj < wl ∈ w0 , . . . , wk = j=1 (Nw0 + uj ). Because of the minimality of uj , classes Nw0 + wl , Nw0 + uj (1 ≤ j ≤ c(k)) are mutually disjoint. Thus c(k) < c(l) ≤ w0 . By repeating this argument, c(m) = w0 for some m. Because w0 ∈ w0 , . . . , wm , a set N \ w0 , . . . , wm is finite. But it should contain an infinite set {wi ; i > m}. Contradiction. (Only if-part) When e = 2, then the class has an infinite elasticity, because of the proof of Theorem 3. The infinite elasticity for e = 2 induces that for e > 2, by considering matrices with the 3rd to e-th rows being all zero. Actually, a semigroup generated from positive integers a and b has a following structure: Lemma 1. For all a, b ∈ N such that gcd(a, b) = d ≥ 1, if n ≥ n0 := ab/d − (a + b) + d ( actually, n0 ≥ ab/d − (a + b) + 1 ) and d divides n then n ∈ Na + Nb.

102

5

Y. Akama

Integer Crystalline Structure: Learning Algorithm as Geometric Algorithm

The class Xkd of integer crystalline structures, introduced in (2), has many examples. – The arrangement of atoms in a ⎛ body centered face centered crys⎞ crystal, a ⎛ ⎞ −1 1 1 1 1 0 2 2 2 2 2 1 ⎠ 3 tal, and a diamond crystal are ⎝ 21 −1 Z , K = ⎝ 21 0 12 ⎠ Z3 , K + 2 2 1 1 1 1 −1 2 2 2 2 2 0  t 0, (1/4, 1/4, 1/4)}. – The vertex sets of periodic tilings(e.g. Archimedean tilings [11]). For example, the vertex set of Archimedean

(3.6.3.6) tiling(i.e. the Kagome lattice) is 1 1/2 √ H(2Z2 + F ) where H = and F = { t (0, 0), t (0, 1), t (1, 0)}, while 0 3/2 4 the vertex set of Archimedean

(3 .6) tiling is the matrix H multiplied by 1 3 the Minkowski sum of Z2 and F , where F consists of t (1, 0), t (1, 1), 2 −1 t (2, 0), t (2, 1), t (3, 0), and t (3, 1). Theorem 7. Xkd has finite elasticity. Proof. X1d has a finite elasticity. Otherwise ∃P1 , P2 , . . . ∈ X1d ∃w0 , w1 , . . . ∀n ≥ 1. {w0 , . . . , wn−1 } ⊆ Pn  w n . So for each n ≥ 1 {0, w 1 − w0 , . . . , wn−1 − w0 } ∈ Pn − w0  w n−1 − w 0 . Because any translated lattice containing the origin is actually a lattice, we have Pn − w0 is a lattice. Thus we have an infinite strictly ascending chain of Z-submodules of a Z-modules Zd , which contradicts that Zd is a Noetherian Z-module (It is well-known that for any Noetherian ring A, M is a Noetherian A-modules if and only if M is finitely generated.) By the finite elasticity of X1d , the elementwise union of k copies of X1d has a finite elasticity, from which a subclass Xkd has too. d Theorem 8. The union X∞ of all Xkd over all k > 0 is not learnable from positive data; hence has an infinite elasticity. d Proof. An infinite subset of Zd belongs to X∞ , and any finite subset F of Zd d d does so too because F = OZ + F ∈ X∞ with O being the zero matrix. That d d d is, X∞ is superfinite. By [12], X∞ is not learnable from positive data. Thus X∞ cannot have finite elasticity.

A fast learning algorithm of X1d can be implemented by using a fast algorithm to compute Hermite normal form. Algorithm 1 – input: x1 , x2 , . . . , – procedure: From x2 − x1 , x3 − x1 , · · · , compute the Z-independent basis a1 , . . . , ad that spans {xi − x1 ; i ≥ 2}, by using Hermite normal form. Set A by [a1 , . . . , ad ], and set f by x2 − x1 .

Comm. Regular Sh-Closed Languages, Noetherian Properties and Learning

103

One of a learning algorithm of Xk1 is the following: Algorithm 2. The input is the data x1 , . . . , xn ∈ Z (n > 1) presented so far. They are all in some D ∈ Xk1 . The outputis a pair of a ∈ Z and a finite F ⊂Z such that aZ + F ∈ Xk1 is minimal among C ∈ Xk1 ; C ⊇ {x1 , . . . , xn } . As the hypothesis of a, the algorithm computes the maximum range of k + 1 adjacent points bounded by the minimum range of k + 2 adjacent points. An idea to generalize the algorithm for Xkd is consider the convex hull of k + 1 points, but it is a difficult problem in general to compute convex hull of points in high dimension. We hope some geometric and combinatorial argument inherent to Xkd helps.

6

Noetherian Spaces

We prove that if the dimension of a Noetherian space X is d, then any ascending chain among unions of two irreducible closed sets has length at most d2 times diagonal Ramsey number of d + 1. We review a basic notions of Noetherian spaces according to [13]. A topological space X is said to be irreducible if X = ∅ and one of the following equivalent conditions (1)–(4) holds, so that all of them hold: (1) X = F1 ∪ F2 for closed sets F1 and F2 in X implies X = F1 or X = F2 . (2) Every open set O = ∅ in X is dense in X . (3) The intersection of a finite number of nonempty open subsets in X is not empty. (4) Every open set in X is connected. A subset E of a topological space X is irreducible if it is irreducible with the relative topology. We say a topological space X is a Noetherian space if for every descending chain F1 ⊇ F2 ⊇ · · · of closed subsets in X , there exists n such that Fn = Fn+1 = · · · , which is equivalent to the condition that every family of closed sets in X has a minimal element with respect to inclusion. For example, for an algebraically closed field Ω containing a field of characteristic 0, the n-fold direct product Ω n with Zariski topology is a Noetherian space. For a Noetherian topological space X , we define the dimension dim X to be the supremum of all integers n such that there exists a sequence Z0  Z1  · · ·  Zn of irreducible closed sets in X . By the union of two topological spaces X = (X, O(X )) and Y = (Y, O(Y)), we mean a topological space Z = (X ∪ Y, O(Z)) such that O(X ) ∪ O(Y) is a subbase of O(Z). Let X1 and X2 be Noetherian spaces of dimensions dim X1 , dim X2 < ∞. Then we have following facts. If Z is the disjoint union of X1 and X2 , then Z is a Noetherian space of dimension max(dim X1 , dim X2 ). If Z is the direct product of X1 and X2 , then Z is a Noetherian space of dimension dim X1 + dim X2 . If Z is the intersection of X1 and X2 , then Z is a Noetherian space of dimension min(dim X1 , dim X2 ). Proposition 7 (Irreducible component decomposition [13]). Let X be a Noetherian space. For any closed set F in X thereexist a positive integer r and r irreducible closed sets Z1 , . . . , Zr such that F = i=1 Zi . The condition Zi ⊆

104

Y. Akama

Zj (i = j) uniquely determines Z1 , . . . , Zr , which are the totality of irreducible components of F . The situation of Theorem 2 also appears when we consider the length of ascending chain of closed sets with 2 irreducible components. Theorem 9. Let X be a Noetherian space of dimension d. If Z1 ∪Z1  Z2 ∪Z2  · · ·  Zn ∪ Zn and all of Zi ’s and Zi ’s are irreducible closed sets in X , then n is less than or equal to d2 R(d + 1, d + 1, 2). The proof of previous Theorem also established a following version of Proposition 1. Theorem 10. If neither X nor Y admits an infinite ascending chain of irreducible closed subsets, then the union does not either.

References 1. Ito, M.: Algebraic theory of automata and languages. World Scientific Publishing Co. Inc., River Edge (2004) 2. Gilmer, R.: Commutative semigroup rings. Chicago Lectures in Mathematics. University of Chicago Press, Chicago (1984) 3. Howie, J.M.: An introduction to semigroup theory. L.M.S. Monographs, vol. 7. Academic Press [Harcourt Brace Jovanovich Publishers], London (1976) 4. Motoki, T., Shinohara, T., Wright, K.: The correct definition of finite elasticity: corrigendum to identification of unions. In: COLT 1991: Proceedings of the fourth annual workshop on Computational learning theory, p. 375. Morgan Kaufmann Publishers Inc., San Francisco (1991) 5. Stephan, F., Ventsov, Y.: Learning algebraic structures from text. Theoret. Comput. Sci. 268(2), 221–273 (2001); Algorithmic learning theory (Otzenhausen 1998) 6. Helmbold, D., Sloan, R., Warmuth, M.K.: Learning integer lattices. SIAM J. Comput. 21(2), 240–266 (1992) 7. Graham, R.L., Rothschild, B.L., Spencer, J.H.: Ramsey theory, 2nd edn. WileyInterscience Series in Discrete Mathematics. John Wiley & Sons, Inc., New York (1980); A Wiley-Interscience Publication 8. Wright, K.: Identification of unions of languages drawn from an identifiable class. In: COLT 1989: Proceedings of the second annual workshop on Computational learning theory, pp. 328–333. Morgan Kaufmann Publishers Inc., San Francisco (1989) 9. Reidenbach, D.: A non-learnable class of e-pattern languages. Theor. Comput. Sci. 350(1), 91–102 (2006) 10. Angluin, D.: Inductive inference of formal languages from positive data. Inform. Control 45(2), 117–135 (1980) 11. Gr¨ unbaum, B., Shephard, G.C.: Tilings and patterns. A Series of Books in the Mathematical Sciences. W. H. Freeman and Company, New York (1989) 12. Gold, E.M.: Language identification in the limit. Inform. Control 10(5), 447–474 (1967) 13. Kimura, T.: Introduction to prehomogeneous vector spaces. Translations of Mathematical Monographs, vol. 215. American Mathematical Society, Providence (2003); Translated from the Japanese original by Makoto Nagura and Tsuyoshi Niitani and revised by the author (2003)

Matching Trace Patterns with Regular Policies Franz Baader1, , Andreas Bauer2 , and Alwen Tiu2 1 TU Dresden, Germany [email protected] 2 The Australian National University {baueran,alwen.tiu}@rsise.anu.edu.au

Abstract. We consider policies that are described by regular expressions, finite automata, or formulae of linear temporal logic (LTL). Such policies are assumed to describe situations that are problematic, and thus should be avoided. Given a trace pattern u, i.e., a sequence of action symbols and variables, were the variables stand for unknown (i.e., not observed) sequences of actions, we ask whether u potentially violates a given policy L, i.e., whether the variables in u can be replaced by sequences of actions such that the resulting trace belongs to L. We also consider the dual case where the regular policy L is supposed to describe all the admissible situations. Here, we want to know whether u always adheres to the given policy L, i.e., whether all instances of u belong to L. We determine the complexity of the violation and the adherence problem, depending on whether trace patterns are linear or not, and on whether the policy is assumed to be fixed or not.

1

Introduction

Regular languages (defined by regular expressions, finite automata, or temporal logics such as LTL) are frequently used in Computer Science to specify the wanted or unwanted behaviour of a system [1,8,3,4]. Such specifications are not only employed in the design phase of the system, where one may try to verify that every execution trace of the system respects the specification [5]. They can also be used in the deployment phase to monitor the actual system trace and raise an alarm if the specification is violated by the behaviour of the system [7,2]. In many of these applications, one actually employs ω-regular languages to describe the infinite behaviour of a reactive system, but in our intended application domain, considering finite sequences of actions (called traces in the following) appears to be more appropriate. In online trading systems, like eBay, formal policies can be used to describe sequences of actions that indicate potentially malicious, dishonest, or fraudulent behaviour (see, e.g., [14]). Of course, it is not always easy to define potentially problematic behaviour without creating too many false positives. But even if such a definition is available, detecting that the actual trace indeed violates the given policy is non-trivial due to the fact that the administrator of an online 

Supported by NICTA, Canberra Research Lab.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 105–116, 2009. c Springer-Verlag Berlin Heidelberg 2009 

106

F. Baader, A. Bauer, and A. Tiu

trading platform may not be able to observe all the relevant user actions. For example, payments made through a third-party institution, shipments of goods, etc., cannot be directly observed. Our approach for modelling this situation is that we use regular languages to describe policies, but instead of traces we consider trace patterns, i.e., traces with variables, where the variables stand for unknown sequences of actions. More formally, assume that L is a policy (formally defined as a regular language) describing undesirable sequences of actions.1 We say that a given trace w violates the policy L if w ∈ L. Checking for a violation is thus just an instance of the word problem for regular languages. If, instead of a trace, we only have a trace pattern, then detecting violations of the policy becomes more complicated. For example, consider the trace pattern abXaY , where a, b are action symbols and X, Y are variables. This trace pattern says: all we know about the actual trace is that it starts with ab, is followed by some trace u, which is followed by a, which is in turn followed by some trace v. Given such a trace pattern, all traces that can be obtained from it by replacing its variables with traces (i.e., finite sequences of actions) are possibly the actual trace. The policy L is potentially violated if one of the traces obtained by such a substitution of the variables by traces belongs to L. In our example, abXaY potentially violates L = (ab)∗ since replacing X by ab and Y by b yields the trace ababab ∈ L. The trace pattern abXaY is linear since every variable occurs at most once in it. We can also consider non-linear trace patterns such as abXaX, where different occurrences of the same variable must be replaced by the same trace. The underlying idea is that, though we do not know which actions took place in the unobserved part of the trace, we know (from some source) that the same sequence of actions took place. It is easy to see that the policy L = (ab)∗ is not potentially violated by abXaX. In this paper, we will show that the complexity of deciding whether a given trace pattern potentially violates a regular policy depends on whether the trace pattern is linear or not. For linear trace patterns, the problem is decidable in polynomial time whereas for non-linear trace patterns the problem is PSpacecomplete. If we assume that the policy is fixed, i.e., its size (more precisely, the size of a finite automaton or regular expression representing it) is constant, then the problem can be solved in linear time for linear trace patterns and is NPcomplete for non-linear trace patterns. We also consider the dual case where the regular policy L is supposed to describe all the admissible situations. Here, we want to know whether u always adheres to the given policy L, i.e., whether all instances of u belong to L. For the case of a fixed policy, the adherence problem is coNP-complete for arbitrary trace patterns and linear for linear trace patterns. If the policy is not assumed to be fixed, however, then the adherence problem is PSpace-complete both for linear and non-linear trace patterns. Finally, we consider the case where the policy is given by an LTL formula. If the policy is not assumed to be fixed, then the violation and the adherence problem are PSpace-complete both for linear and non-linear trace patterns. For the case of a 1

Using regular languages of finite words to express policies means that we only monitor safety properties [11]. For more general notions of policies, see [20].

Matching Trace Patterns with Regular Policies

107

fixed policy, the violation (adherence) problem is NP-complete (coNP-complete) for non-linear patterns and it can be solved in linear time for linear patterns.

2

Preliminaries

In the following, we consider finite alphabets Σ, whose elements are called action symbols. A trace is a (finite) word over Σ, i.e., an element of Σ ∗ . A trace pattern is an element of (Σ ∪V)∗ , i.e., a finite word over the extended alphabet Σ ∪V, where V is a finite set of trace variables. The trace pattern u is called linear if every trace variable occurs at most once in u. A substitution is a mapping σ : V → Σ ∗ . This mapping is extended to a mapping σ  : (Σ ∪ V)∗ → Σ ∗ in the obvious way, by defining σ (ε) = ε for the empty word ε, σ  (a) = a for every action symbol a ∈ Σ, σ (X) = σ(X) for every trace variable X ∈ V, and σ (uv) = σ (u) σ (v) for every pair of non-empty trace patterns u, v. A policy is a regular language over Σ. We assume that such a policy is given either by a regular expression or by a (non-deterministic) finite automaton. For our complexity results, it is irrelevant which of these representations we actually use. Definition 1. Given a trace pattern u and a policy L, we say that u potentially violates L (written u  L) if there is a substitution σ such that σ  (u) ∈ L. The violation problem is the following decision problem: Given: A policy L and a trace pattern u. Question: Does u  L hold or not? If the trace pattern u in this decision problem is restricted to being linear, then we call this the linear violation problem. We assume that the reader is familiar with regular expressions and finite automata. Given a (non-deterministic) finite automaton A, states p, q in A, and a word w, we write p →w A q to say that there is a path in A from p to q with label w. The set of labels of all paths from p to q is denoted by Lp,q . The following problem turns out to be closely connected to the violation problem. The intersection emptiness problem for regular languages is the following decision problem: Given: Regular languages L1 , . . . , Ln . Question: Does L1 ∩ . . . ∩ Ln = ∅ hold or not? This problem is PSpace-complete [13,10], independent of whether the languages are given as regular expressions, non-deterministic finite automata, or deterministic finite automata.

3

The Linear Violation Problem

Assume that u is a linear trace pattern and L is a regular language. Let the trace pattern u be of the form u = u0 X1 u1 . . . Xm um where ui ∈ Σ ∗ (i = 0, . . . , m) and X1 , . . . , Xm are distinct variables. Obviously, we have u  L iff u0 Σ ∗ u1 . . . Σ ∗ um ∩ L = ∅.

108

F. Baader, A. Bauer, and A. Tiu

a

b

a

a, b

a, b

Fig. 1. A non-deterministic finite automaton accepting abΣ ∗ aΣ ∗

If n is the length of u0 u1 . . . um , then we can build a non-deterministic finite automaton A accepting the language u0 Σ ∗ u1 . . . Σ ∗ um that has n + 1 states. For example, given the linear trace pattern abXaY from the introduction, we consider the language abΣ ∗ aΣ ∗ , where Σ = {a, b}. Fig. 1 shows a non-deterministic finite automaton with 4 states accepting this language. In addition, there is a non-deterministic finite automaton B accepting L such that the number of states  of B is polynomial in the size of the original representation for L.2 By constructing the product automaton of A and B, we obtain a non-deterministic finite automaton accepting u0 Σ ∗ u1 . . . Σ ∗ um ∩ L with (n + 1) ·  states. Thus, emptiness of this language can be tested in time linear in (n + 1) · , and thus in time polynomial in the size of the input u, L of our linear violation problem. If the policy is assumed to be fixed, then  is a constant, and thus emptiness of the automaton accepting u0 Σ ∗ u1 . . . Σ ∗ um ∩ L can be tested in time linear in the length of u. Theorem 1. The linear violation problem can be solved in polynomial time. If the policy is assumed to be fixed, it can even be solved in time linear in the length of the input trace pattern.

4

The General Violation Problem

Allowing also the use of non-linear patterns increases the complexity. Theorem 2. The violation problem is PSpace-complete. Proof. PSpace-hardness can be shown by a reduction of the intersection emptiness problem for regular languages. Given regular languages L1 , . . . , Ln , we construct the trace pattern un := #X#X . . . #X# of length 2n + 1 and the policy L(L1 , . . . , Ln ) := #L1 #L2 . . . #Ln #. Here X is a variable and # is a new action symbol not occurring in any of the words belonging to one of the languages L1 , . . . , Ln . Obviously, both un and (a representation of) L(L1 , . . . , Ln ) can be constructed in time polynomial in the size of (the representation of) L1 , . . . , Ln . To be more precise regarding the representation issue, if we want to show PSpacehardness for the case where the policy is given by a regular expression (a nondeterministic finite automaton, a deterministic finite automaton), then we assume 2

In fact, it is well-known that, given a regular expression r for L, one can construct a non-deterministic finite automaton accepting L in time polynomial in the size of r.

Matching Trace Patterns with Regular Policies

109

that the regular languages L1 , . . . , Ln are given by the same kind of representation. It is easy to see that the following equivalence holds: L1 ∩ . . . ∩ Ln = ∅ iff un  L(L1 , . . . , Ln ). Thus, we have shown that the intersection emptiness problem for regular languages can be reduced in polynomial time to the violation problem. Since the intersection emptiness problem is PSpace-complete [13] (independent of whether the regular languages are given as regular expressions, non-deterministic finite automata, or deterministic finite automata), this shows that the violation problem is PSpace-hard (again independent of the chosen representation). To show membership of the violation problem in PSpace, consider the violation problem for the trace pattern u and the policy L. Let n be the length of u and A a non-deterministic finite automaton accepting L. For i ∈ {1, . . . , n}, we denote the symbol in Σ ∪ V occurring at position i in u with ui , and for every variable X occurring in u, we denote the set of positions in u at which X occurs with PX , i.e., PX = {i | 1 ≤ i ≤ n ∧ ui = X}. It is easy to see that u  L iff there is a sequence q0 , . . . , qn of states of A such that the following conditions are satisfied: 1. q0 is an initial state and qn is a final state; ui 2. for every i ∈ {1, . . . , n}, if ui ∈ Σ, then qi−1 → A qi ; 3. for every variable X occurring in u, we have i∈PX Lqi−1 ,qi = ∅.3 Based on this characterisation of “u  L” we can obtain a PSpace decision procedure for the violation problem as follows. This procedure is nondeterministic, which is not a problem since NPSpace = PSpace by Savitch’s theorem [19]. It guesses a sequence q0 , . . . , qn of states of A, and then checks whether this sequence satisfies the Conditions 1–3 from above. Obviously, the first two conditions can be checked in polynomial time, and the third condition can be checked within PSpace since the intersection emptiness problem for regular languages is PSpace-complete [13]. 

Alternatively, we could have shown membership in PSpace by reducing it to the known PSpace-complete problem of solvability of word equations with regular constraints [21,17]. Due to limited space and the fact that the algorithm for testing solvability of word equations with regular constraints described in [17] is rather complicated and “impractical,” we do not describe this reduction here. Let us now consider the complexity of the violation problem for the case where the policy is assumed to be fixed. In this case, the NPSpace algorithm described in the proof of Theorem 2 actually becomes an NP algorithm. In fact, guessing the sequence of states q0 , . . . , qn can be realized using polynomially many binary choices (i.e., with an NP algorithm), testing Conditions 1 and 2 is clearly polynomial, and testing Condition 3 becomes polynomial since the size of A, and thus of non-deterministic finite automata accepting the languages Lqi−1 ,qi , is constant. 3

Recall that Lp,q denotes the set of words labeling paths in A from p to q.

110

F. Baader, A. Bauer, and A. Tiu

Theorem 3. If the policy is assumed to be fixed, then the violation problem is in NP. The matching NP-hardness result of course depends on the fixed policy. For example, if L = Σ ∗ , then we have u  L for all trace patterns u, and thus the violation problem for this fixed policy can be solved in constant time. However, we can show that there are policies for which the problem is NP-hard. Given a fixed policy L, the violation problem for L is the following decision problem Given: A trace pattern u. Question: Does u  L hold or not? Theorem 4. There exists a fixed policy such that the violation problem for this policy is NP-hard. Proof. To show NP-hardness, we use a reduction from the well-known NPcomplete problem 3SAT [10]. Let C = c1 ∧ . . . ∧ cm be an instance of 3SAT, and P = {p1 , . . . , pn } the set of propositional variables occurring in C. Every 3-clause ci in C is of the form ci = li,1 ∨ li,2 ∨ li,3 , where the li,j are literals, i.e., propositional variables or negated propositional variables. In the corresponding violation problem, we use the elements of V := {Pi | pi ∈ P} as trace variables, and as alphabet we take Σ := {#, ¬, ∨, ∧, , ⊥}. The positive literal pi is encoded as the trace pattern #Pi # and the negative literal ¬pi as ¬#Pi #. For a given literal l, we denote its encoding as a trace pattern by ι(l). 3-Clauses are encoded as “disjunctions” of the encodings of their literals, i.e., ci = li,1 ∨li,2 ∨li,3 is encoded as ι(ci ) = ι(li,1 )∨ι(li,2 )∨ι(li,3 ), and 3SAT-problems are encoded as “conjunctions” of their 3-clauses, i.e., if C = c1 ∧ . . . ∧ cm , then ι(C) = ι(c1 )∧ . . . ∧ι(cm ). Our fixed policy describes all situations that can make a 3-clause true. To be more precise, consider ι(c) = ι(l1 )∨ι(l2 )∨ι(l3 ) for a 3-clause c = l1 ∨ l2 ∨ l3 . If we replace the trace variables in c by either or ⊥, then we get a trace of the form w1 ∨w2 ∨w3 where each wi belongs to the set K := {# #, #⊥#, ¬# #, ¬#⊥#}. Intuitively, replacing the trace variable Pi by (⊥) corresponds to replacing the propositional variable pi by true (false). Thus, a substitution σ that replaces trace variables by or ⊥ corresponds to a propositional valuation vσ . The  (ι(c)) = w1 ∨w2 ∨w3 is such that valuation vσ makes the 3-clause c true iff σ there is an i, 1 ≤ i ≤ 3, with wi ∈ {# #, ¬#⊥#}. For this reason, we define T := {w1 ∨w2 ∨w3 | {w1 , w2 , w3 } ⊆ K and there is an i, 1 ≤ i ≤ 3, with wi ∈ {# #, ¬#⊥#}}. To make a conjunction of 3-clauses true, we must make every conjunct true. Consequently, we define our fixed policy L as L3SAT := (T ∧)∗ T. Since T is a finite language, L3SAT is obviously a regular language. NP-hardness of the violation problem for L3SAT is an immediate consequence of the (easy to prove) fact that C is satisfiable iff ι(C)  L3SAT . 

Matching Trace Patterns with Regular Policies

5

111

The Adherence Problem

Instead of using regular languages to describe traces that are viewed as being problematic, one could assume that a regular policy L describes all the admissible situations. In this case, we want to know whether u always adheres L. Definition 2. Given a trace pattern u and a policy L, we say that u always adheres to L (written u |= L) if σ (u) ∈ L holds for all substitutions σ. The adherence problem is the following decision problem: Given: A policy L and a trace pattern u. Question: Does u |= L hold or not? If the trace pattern u in this decision problem is restricted to being linear, then we call this the linear adherence problem. Obviously, we have u |= L iff not u  Σ ∗ \ L, which shows that the adherence problem and the complement of the violation problem can be reduced to each other. If the policy L is assumed to be fixed, then these reductions are linear in the length of u. Thus, we obtain the following corollary to our Theorems 1, 3, and 4. Corollary 1. Assume that the policy is fixed. Then, the linear adherence problem can be solved in time linear in the length of the input trace pattern. In addition, the general adherence problem is in coNP, and there exists a policy such that the general adherence problem for this policy is coNP-hard. Another case for which the above reductions are linear is if the policy is given by a deterministic finite automaton. Thus, our Theorems 1 and 2 yield the following corollary. Corollary 2. Assume that the policy is given by a deterministic finite automaton. Then, the linear adherence problem can be solved in polynomial time, and the general adherence problem is PSpace-complete. If the policy is neither fixed nor given by a deterministic finite automaton, then the reductions between the adherence problem and the complement of the violation problem are not polynomial since they involve the (potentially exponential) construction of the complement automaton for a non-deterministic finite automaton. In fact, in this case there cannot be a polynomial time reduction between the two problems since the adherence problem is intractable even for linear trace patterns, for which the violation problem is tractable. Lemma 1. The linear adherence problem is PSpace-hard if the policy is given by a non-deterministic finite automaton or a regular expression. Proof. Consider the linear trace pattern X and an arbitrary regular language L over the alphabet Σ. Obviously, we have X |= L iff L = Σ ∗ . The problem of deciding whether a regular language (given by a regular expression or a nondeterministic finite automaton) is the universal language Σ ∗ or not is PSpacecomplete [10]. Consequently, the adherence problem is PSpace-hard even for linear trace patterns. 

112

F. Baader, A. Bauer, and A. Tiu

Obviously, this PSpace lower bound then also holds for the general adherence problem. Next, we show that a matching PSpace upper bound holds for the general adherence problem, and thus for the linear one as well. Lemma 2. The adherence problem is in PSpace if the policy is given by a nondeterministic finite automaton or a regular expression. Proof. Since PSpace is a deterministic complexity class, it is sufficient to show that the complement of the adherence problem is in PSpace. Thus, given the trace pattern u of length n and the policy L, we want to decide whether u |= L does not hold. As noted above, this is the same as deciding whether u  Σ ∗ \ L. Basically, we will use the PSpace decision procedure for the violation problem described in the proof of Theorem 2 to decide this problem. However, we cannot explicitly construct the automaton for Σ ∗ \ L from the one for L since the size of this automaton might be exponential in the size of the automaton (or regular expression) for L. Instead, we construct the relevant parts of this automaton on-the-fly. Let A be a non-deterministic finite automaton accepting L that has k states, and B the deterministic automaton for Σ ∗ \ L constructed in the usual way from A, i.e., the states of B are all the subsets of the set of states of A, the initial state of B is the set of initial states of A, the final states of B are the sets not containing any final state of A, and P →aB Q iff Q = {q | ∃p ∈ P : p →aA q}. Although the size of B is exponential in the size of A, every single state of B can be represented using linear space. Also, deciding whether a given state of B is the initial state or a final state requires only polynomial space, and the same is true for constructing, for a given state P of B and a ∈ Σ, the unique state Q such that P →aB Q. For i ∈ {1, . . . , n}, we again denote the symbol in Σ ∪ V occurring at position i in u with ui , and for every variable X occurring in u, we denote the set of positions in u at which X occurs with PX , i.e., PX = {i | 1 ≤ i ≤ n ∧ ui = X}. Then u  Σ ∗ \ L iff there is a sequence Q0 , . . . , Qn of states of B such that the following conditions are satisfied: 1. Q0 is the initial state and Qn is a final state of B; 2. for every i ∈ {1, . . . , n}, if ui ∈ Σ, then Qi−1  →uBi Qi ; 3. for every variable X occurring in u, we have i∈PX LQi−1 ,Qi = ∅. Obviously, this characterisation yields the desired PSpace decision procedure for u  Σ ∗ \ L if we can show that, for each variable X, the non-emptiness of  i∈PX LQi−1 ,Qi can be decided by an NPSpace procedure. Let PX = {i1 , . . . , im }, and Ij := Qij −1 , Fj := Qij for j= 1, . . . , m. Note that m ≤ n where n is the length of the pattern u. To check 1≤j≤m LIj ,Fj = ∅, we proceed as follows. 1. Start with the m-tuple (T1 , . . . , Tm ) where Tj := Ij for j = 1, . . . , m. then termi2. Check whether (T1 , . . . , Tm ) = (F1 , . . . , Fm ). If this is the case,  nate successfully, i.e., with the result that the intersection 1≤j≤m LIj ,Fj is non-empty. Otherwise, continue with 3.

Matching Trace Patterns with Regular Policies

113

3. Guess a letter a ∈ Σ, and replace (T1 , . . . , Tm ) by the corresponding tuple of successor states in B, i.e., make the assignment Tj := {q | ∃p ∈ Tj : p →aA q}. Continue with 2.  Obviously, if this procedure terminates successfully, then 1≤j≤m LIj ,Fj is indeed non-empty. In addition, if the intersection is non-empty, then there is a way of guessing letters such that the procedure terminates successfully. However, as described until now, the procedure does not terminate if the intersection is empty. It is, however, easy to see that it is enough to guess a sequence of letters of length at most 2k·m , which is the number of different tuples (T1 , . . . , Tm ) to be encountered during a run of the procedure.4 In fact, if a tuple is reached more than once in a run of our procedure, then we can cut out this cycle to get a shorter run that achieves the same. Consequently, one can stop each run after 2k·m iterations. This can be realized using a binary counter that requires k · m bits, i.e., space polynomial in the size of the input. 

The following theorem is an immediate consequence of the two lemmas that we have just shown. Theorem 5. Both the general and the linear adherence problem are PSpacecomplete if the policy is given by a non-deterministic finite automaton or a regular expression.

6

Policies Defined by LTL Formulae

In many applications, linear temporal logic (LTL) [18] is used to specify the (wanted or unwanted) behaviour of a system [15]. LTL is usually interpreted in temporal structures with infinitely many time points, but variants where temporal structures are finite sequences of time points have also been considered in the literature [6,9]. Here, we consider the setting employed in [6], where an LTL formula ϕ defines a regular language of finite words, which we denote by Lϕ in the following. It is well-known that not all regular languages can be defined by LTL formulae: the class of languages definable by LTL formulae is precisely the class of star-free languages, which is a strict subclass of the class of all regular languages [6]. Given an LTL formula ϕ, one can construct a finite non-deterministic automaton Aϕ that accepts Lϕ (by adapting the Vardi-Wolper construction [23] to the finite case). Although the size of this automaton is exponential in the size of ϕ, it satisfies properties similar to the ones mentioned for the automaton B in the proof of Lemma 2: every single state of Aϕ can be represented using linear space, deciding whether a given state of Aϕ is an initial state or a final state requires only polynomial space, and the same is true for guessing, for a given state p of Aϕ and a ∈ Σ, a state q such that p →aAϕ q. We will also use that, just as in the infinite case, the satisfiability problem for LTL over finite temporal structures (i.e., for a given LTL formula ϕ, decide whether Lϕ is empty or not) 4

Recall that k is the number of states of A, and m ≤ n where n is the length of the input pattern u.

114

F. Baader, A. Bauer, and A. Tiu

is PSpace-complete (this can be shown by a proof identical to the one in [22] for the infinite case). In this section, we consider the complexity of the violation (adherence) problem for the case where the policy Lϕ is given by an LTL formula ϕ. First, note that the adherence and the violation problem can be reduced to each other in linear time since LTL allows for negation: u  Lϕ iff u |= L¬ϕ

and

u |= Lϕ iff u  L¬ϕ .

Theorem 6. Both the general and the linear violation (adherence) problem are PSpace-complete if the policy is given by an LTL formula. Proof. It is sufficient to show PSpace-completeness for the violation problem. PSpace-hardness of the violation problem can be shown by a reduction of the satisfiability problem: the LTL formula ϕ is satisfiable iff X  Lϕ . Membership in PSpace can be shown just as in the proof of Lemma 2. We apply the PSpace decision procedure described in the proof of Theorem 2 to the automaton Aϕ , but without constructing this automaton explicitly. Instead, its relevant parts are constructed on the fly. Again, the main fact to be shown is that the induced intersection emptiness problems for the variable can be decided within PSpace. This can be done just as in the proof of Lemma 2. The only difference is that the automaton Aϕ is non-deterministic whereas the automaton B considered in the proof of Lemma 2 was deterministic. However, this just means that, instead of constructing the unique tuple of successors states in Step 3, we guess such a successor tuple. 

Let us now consider the case where the policy (i.e., the LTL formula) is assumed to be fixed. This means that the size of the automaton Aϕ is a constant. For the case of linear patterns, we can then decide the violation problem (and thus also the adherence problem) in linear time (see the proof of the second part of Theorem 1). Theorem 7. Assume that the policy is fixed and given by an LTL formula. Then, the linear violation problem and the linear adherence problem can be solved in time linear in the length of the input trace pattern. For non-linear trace patterns, the violation problem for fixed LTL policies has the same complexity as in the case of fixed regular policies. The results for the adherence problem then follow from the above reductions between the violation problem and the (complement of the) adherence problem. The proof of the following theorem is identical to the one of Theorem 3. Theorem 8. Assume that the policy is fixed and given by an LTL formula. Then the violation problem is in NP and the adherence problem is in coNP. In order to show NP-hardness of the violation problem for a fixed policy ϕ (which then implies coNP-hardness of the adherence problem for the fixed policy ¬ϕ), it is enough to show that the fixed policy (T ∧)∗ T used in the proof of Theorem 4

Matching Trace Patterns with Regular Policies

115

is star-free [6]. Since the star-free languages are closed under complement, it is enough to show that the complement of this language is star-free. By definition, finite languages (and thus also T ) are star-free. In addition, star-free languages are closed under all Boolean operations and concatenation. It is also well-known (and easy to see) that Σ ∗ as well as (Σ \ {a})∗ for any a ∈ Σ are star-free [16]. The language Σ ∗ \ (T ∧)∗ T is the union of the following star-free languages: – all words not containing ∧ and not belonging to T : (Σ ∗ \ T ) ∩ (Σ \ {∧})∗ . – all words not starting with an element of T before the first ∧: ((Σ ∗ \ T ) ∩ (Σ \ {∧})∗ )∧Σ ∗ . – all words not having a word of T between two consecutive occurrences of ∧: Σ ∗ ∧((Σ ∗ \ T ) ∩ (Σ \ {∧})∗ )∧Σ ∗ . – all words not ending with an element of T after the last ∧: Σ ∗ ∧((Σ ∗ \ T ) ∩ (Σ \ {∧})∗ ). This shows that (T ∧)∗ T is star-free and thus can be expressed by an LTL formula ϕ. Thus, the proof of Theorem 4 yields the following results. Theorem 9. There exists a fixed policy given by an LTL formula such that the violation problem (adherence problem) for this policy is NP-hard (coNP-hard).

7

Future Work

One of the main tasks to be addressed in our future work is to investigate which kinds of unwanted behaviour in online trading systems one can formally describe using regular languages and LTL formulae. We also intend to consider the problem of debugging policies as another application for our approach of matching trace patterns with regular policies. The violation and the adherence problem can be viewed as instances of the policy querying problem, which has been introduced in [12] as a tool for the analysis of access control policies. The main idea is that, while it may be quite hard for inexperienced users to correctly define a policy using a regular expression or an LTL formula, it should be easier to describe, using trace patterns, types of traces they want to allow or disallow. Checking for violation/adherence can then be used to find potential errors in the definition of the policy.

References 1. Armoni, R., Fix, L., Flaisher, A., Gerth, R., Ginsburg, B., Kanza, T., Landver, A., Mador-Haim, S., Singerman, E., Tiemeyer, A., Vardi, M.Y., Zbar, Y.: The forSpec temporal logic: A new temporal property-specification language. In: Katoen, J.P., Stevens, P. (eds.) TACAS 2002. LNCS, vol. 2280, p. 296. Springer, Heidelberg (2002) 2. Bauer, A., Leucker, M., Schallhart, C.: Monitoring of real-time properties. In: ArunKumar, S., Garg, N. (eds.) FSTTCS 2006. LNCS, vol. 4337, pp. 260–272. Springer, Heidelberg (2006)

116

F. Baader, A. Bauer, and A. Tiu

3. Bauer, A., Leucker, M., Streit, J.: SALT—structured assertion language for temporal logic. In: Liu, Z., He, J. (eds.) ICFEM 2006. LNCS, vol. 4260, pp. 757–775. Springer, Heidelberg (2006) 4. Ben-David, S., Fisman, D., Ruah, S.: Embedding finite automata within regular expressions. Theoretical Computer Science 404, 202–218 (2008) 5. Clarke, E.M., Grumberg, O., Peled, D.A.: Model Checking. MIT Press, Cambridge (1999) 6. Cohen, J., Perrin, D., Pin, J.-E.: On the expressive power of temporal logic. J. Comput. System Sci. 46, 271–294 (1993) 7. Colin, S., Mariani, L.: Run-time verification. In: Broy, M., Jonsson, B., Katoen, J.-P., Leucker, M., Pretschner, A. (eds.) Model-Based Testing of Reactive Systems. LNCS, vol. 3472, pp. 525–555. Springer, Heidelberg (2005) 8. Eisner, C., Fisman, D.: A Practical Introduction to PSL. Series on Integrated Circuits and Systems. Springer, Heidelberg (2006) 9. Eisner, C., Fisman, D., Havlicek, J., Lustig, Y., McIsaac, A., van Campenhout, D.: Reasoning with temporal logic on truncated paths. In: Hunt Jr., W.A., Somenzi, F. (eds.) CAV 2003. LNCS, vol. 2725, pp. 27–39. Springer, Heidelberg (2003) 10. Garey, M.R., Johnson, D.S.: Computers and Intractability — A guide to NPcompleteness. W. H. Freeman and Company, San Francisco (1979) 11. Havelund, K., Rosu, G.: Synthesizing monitors for safety properties. In: Katoen, J.-P., Stevens, P. (eds.) TACAS 2002. LNCS, vol. 2280, p. 342. Springer, Heidelberg (2002) 12. Kirchner, C., Kirchner, H., Santana de Oliveira, A.: Analysis of rewrite-based access control policies. In: Proc. 3rd International Workshop on Security and Rewriting Techniques (2008) 13. Kozen, D.: Lower bounds for natural proof systems. In: Proc. FOCS 1977. IEEE Computer Society, Los Alamitos (1977) 14. Krukow, K., Nielsen, M., Sassone, V.: A framework for concrete reputation-systems with applications to history-based access control. In: Proc. ACM Conference on Computer and Communications Security. ACM, New York (2005) 15. Manna, Z., Pnueli, A.: The Temporal Logic of Reactive and Concurrent Systems: Specification. Springer, Heidelberg (1992) 16. Perrin, D.: Finite Automata. In: van Leeuwen, J. (ed.) Handbook of Theoretical Computer Science, vol. B. Elsevier, Amsterdam (1990) 17. Plandowski, W.: Satisfiability of word equations with constants is in PSPACE. In: Proc. FOCS 1999. IEEE Computer Society, Los Alamitos (1999) 18. Pnueli, A.: The temporal logic of programs. In: Proc. FOCS 1977. IEEE Computer Society, Los Alamitos (1977) 19. Savitch, W.J.: Relationship between nondeterministic and deterministic tape complexities. J. of Computer and System Sciences 4, 177–192 (1970) 20. Schneider, F.B.: Enforceable security policies. ACM Trans. Inf. Syst. Secur. 3(1), 30–50 (2000) 21. Schulz, K.U.: Makanin’s algorithm for word equations - two improvements and a generalization. In: Schulz, K.U. (ed.) IWWERT 1990. LNCS, vol. 572. Springer, Heidelberg (1992) 22. Prasad Sistla, A., Clarke, E.C.: The complexity of propositional linear temporal logic. J. of the ACM 32(3), 733–749 (1985) 23. Vardi, M.Y., Wolper, P.: Automata-theoretic techniques for modal logics of programs. In: Proc. STOC 1984 (1984)

Absolute Convergence of Rational Series Is Semi-decidable Rapha¨el Bailly and Fran¸cois Denis Laboratoire d’Informatique Fondamentale de Marseille CNRS, Aix-Marseille Universit´e {raphael.bailly,francois.denis}@lif.univ-mrs.fr Abstract. We study real-valued absolutely convergent rational series, ∗ i.e. functions r : Σ ∗ → R, defined over a free monoid Σ , that can be computed by a multiplicity automaton A and such that w∈Σ ∗ |r(w)| < ∞. We prove that any absolutely convergent rational series r can be computed by a multiplicity automaton A which has the property that r|A| is simply convergent, where r|A| is the series computed by the automaton |A| derived from A by taking the absolute values of all its parameters. Then, we prove that the set Arat (Σ) composed of all absolutely convergent rational series is semi-decidable and we show that the sum  rat (Σ). w∈Σ ∗ |r(w)| can be estimated to any accuracy rate for any r ∈ A We also introduce a spectral radius-like parameter ρ|r| which satisfies the following property: r is absolutely convergent iff ρ|r| < 1.

1

Introduction

Given a finite alphabet Σ, we consider real formal power series defined over the free monoid Σ ∗ , i.e. functions which map Σ ∗ into R. More precisely, we consider rational series, which admit several characterizations, one of which being that they can be computed by multiplicity automata [1,2]. Given a rational series r : Σ ∗ → R, we study whether r is absolutely convergent, i.e.  w∈Σ ∗ |r(w)| < ∞. It is polynomially decidable  whether a rational series r is  simply convergent, i.e. whether the sum n≥0 w∈Σ n r(w) converges to a limit (see [3] for example). Since the Hadamard product r of two rational series s and t, defined by r(w) = s(w)t(w), is rational, it is polynomially decidable whether a  rational series r converges in quadratic norm, i.e. w∈Σ ∗ r2 (w) < ∞. However, to our knowledge, it is still unknown whether it can be decided if a rational series is absolutely convergent. The motivation for the present work comes from a problem we have studied in grammatical inference. A stochastic  language over Σ ∗ is a series p which takes only non negative values and s.t. w∈Σ ∗ p(w) = 11 . A classical problem in grammatical inference consists in inferring an estimate of a target stochastic language p from a finite sample of words {w1 , . . . , wn } independently drawn according to p. In [4], we proposed an algorithm DEES which takes a sample  1

This research was partially supported by the ANR project Marmota. This definition differs from the one given in [2].

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 117–128, 2009. c Springer-Verlag Berlin Heidelberg 2009 

118

R. Bailly and F. Denis

as input and outputs a rational series r which simply converges to 1 but can take negative values, and which satisfies the following property:  with probability one, there exists a sample size level from which the sum w∈Σ ∗ |p(w) − r(w)| is arbitrarily small, (which implies that r is absolutely convergent); moreover, a stochastic language pr can be computed from r, that satisfies  w∈Σ ∗

|pr (w) − r(w)| ≤



|r|(w) − 1.

w∈Σ ∗

In other words, we know that from some sample size, we will have a solution of our problem. But we need to decide whether the series r output by DEES from the working sample is absolutely convergent  to ensure that r provides a solution and we need to compute an estimate of w∈Σ ∗ |r|(w) to bound the accuracy of this solution. A multiplicity automaton (MA) is a tuple A = Σ, Q, ϕ, ι, τ , where Q is a finite set of states, ϕ (resp. ι, τ ) is a transition (resp. initialization, termination) function, which can be used to compute a rational series rA . Any rational series r can be computed by a MA. Given a MA A, we obtain a new MA |A| by taking the absolute values of the functions ϕ, ι and τ . It is straightforward that rA is absolutely convergent if r|A| is simply convergent. We prove that any absolutely convergent rational series r can be computed by a multiplicity automaton A which has the property that r|A| is simply convergent. Then, we provide an algorithm which takes a multiplicity automaton B as input and halts if and only if rB is absolutely convergent: when the algorithm halts, it outputs a MA A equivalent to B, i.e. the series computed by A and B are equal, and such that r|A| is convergent. So, we have proved that the set Arat (Σ) composed of all absolutely convergent rational series is semi-decidable.  |r(w)| can be estimated from below by computing the sum The sum ∗ w∈Σ  |r(w)| for increasing integers n. We prove that  our algorithm can be ≤n w∈Σ used to provide convergent upper bounds. So, the sum w∈Σ ∗ |r(w)| can be estimated to any accuracy rate. As a consequence, if the L1-distance ||r − s||1 =  |r(w) − s(w)| is finite, it can be estimated to any accuracy rate. It has ∗ w∈Σ been proved in [5] that computing the L1-distance between two hidden Markov models is N P -hard which implies that computing the L1-distance between two MA is N P -hard too. Lp distances of two probabilistic automata have been studied in [6,7], where efficient algorithm have been provided when p is even. Our algorithm can be used to estimate Lp distances between two rational series for any odd values of p. Finally, for any rational series r, we introduce a spectral radius-like parameter, ρ|r| defined by ρ|r| = limsupn(|r|(Σ n ))1/n and we show that r is absolutely convergent iff ρ|r| < 1. We recall some properties on rational series and multiplicity automata in Section 2. We study absolutely convergent series in Section 3; in particular, we prove that any absolutely convergent rational series can be represented by a MA A such that r|A| is convergent. We provethe semi-decidability of the class Arat (Σ) in Section 4. We show how the sum w∈Σ ∗ |r(w)| can be estimated in

Absolute Convergence of Rational Series Is Semi-decidable

119

Section 5. To conclude, we provide some comments and describe some conjectures and future works in Section 6.

2

Preliminaries

2.1

Rational Series

Let Σ ∗ be the set of words on the finite alphabet Σ. The empty word is denoted by ε, and the length of a word u is denoted by |u|. For any integer k, we denote by Σ k the set {u ∈ Σ ∗ | |u| = k} and by Σ ≤k the set {u ∈ Σ ∗ | |u| ≤ k}. A subset S of Σ ∗ is prefix-closed if for any u, v ∈ Σ ∗ uv ∈ S ⇒ u ∈ S. The general context is, for an alphabet Σ the set R Σ of all the mappings from Σ ∗ into R. An element of this set is called a formal power series. This set ˙ is an R-vector space. For any series r and any word u ∈ Σ ∗ , we denote by ur the series defined by ur(w) ˙ = r(uw). Let LH(r) denote the linear hull of r, i.e. the vector subspace of R Σ spanned by {ur|u ˙ ∈ Σ ∗ }. A multiplicity automaton (MA) is a tuple Σ, Q, ϕ, ι, τ  where Q is a finite set of states, ϕ : Q × Σ × Q → R is the transition function, ι : Q → R is the initialization function and τ : Q → R is the termination function. Let QI = {q ∈ Q|ι(q) = 0} be the set of initial states and QT = {q ∈ Q|τ (q) = 0} be the set of terminal the transition function ϕ to Q × Σ ∗ × Q  states. We extend    by ϕ(q, wx, q ) = q ∈Q ϕ(q, w, q )ϕ(q , x, q  ) and ϕ(q, ε, q  ) = 1 if q = q  and 0 ∗ otherwise, for any q, q  ∈ Q, x ∈ Σ and subset L ⊂ Σ ∗ w ∈ Σ . For any finite    and any Q ⊆ Q, define ϕ(q, L, Q ) = w∈L,q ∈Q ϕ(q,  w, q ). For any MA A = Σ, Q, ϕ, ι, τ , we define the series rA by rA (w) = q,q ∈Q ι(q)ϕ(q, w, q  )τ (q  ). For any q ∈ Q, we define the series rA,q by rA,q (w) = q ∈Q ϕ(q, w, q  )τ (q  ). The support of a MA Σ, Q, ϕ, ι, τ  is a non deterministic finite automaton (NFA) Σ, Q, δ, QI , QF  where the transition function is defined by δ(q, x) = {q  ∈ Q|ϕ(q, x, q  ) = 0}. We will say that a series r is rational if it satisfies one of the two following equivalent conditions: 1. the dimension of LH(r) is finite; 2. r can be computed by a multiplicity automaton. The family of all rational series is denoted by Rrat Σ. 2.2

Prefixial Multiplicity Automata

Representation of rational series based on prefix sets has been introduced in [1]. Definition 1. Let A = Σ, Q, ϕ, ι, τ  be a MA. We say that A is prefixial if: – Q is non-empty prefix-closed finite subset of Σ ∗ – ∀u ∈ Q, ι(u) = 0 iff u = ε – ∀x ∈ Σ, ∀u, v ∈ Q s.t. ux ∈ Q, ϕ(u, x, v) = 0 iff v = ux.

120

R. Bailly and F. Denis

A transition (u, x, v) is called an inner transition if v = ux and a border transition otherwise. The set F = {ux|u ∈ Q, x ∈ Σ, ux ∈ Q} is called the frontier set of A. An NFA A = Σ, Q, δ, I, F  is prefixial if A is the support of a prefixial MA. A prefix-closed subset Q of Σ ∗ can be used as the set of states of a prefixial automaton that computes a rational series r if and only if the set {ur|u ˙ ∈ Q} spans LH(r). Let us make this statement precise. Let r be a rational series and let Q be a prefix-closed subset such that {ur|u ˙ ∈ Q} spans LH(r). Let F = {ux|u ∈ Q, x ∈ Σ, ux ∈ Q}. Let f : Q → R and g : F × Q → R be two mappings that satisfy: 1. f (u) = 0 for every state u,  ˙ = v∈Q g(ux, v) f (u) vr ˙ for every ux ∈ F where f is defined by f (ε) = 2. uxr f(v)

f (ε), where f (wx) = f (w)f (wx) for any w ∈ Σ ∗ and x ∈ Σ and where the top bar notation is meant to express that the “dot” applies to the element under the bar. The function g expresses linear dependencies.

We define the prefixial automaton A(Σ, Q, f, g, r) = Σ, Q, ϕ, ι, τ  by – – – –

ι(ε) = f (ε), ∀u ∈ Q, x ∈ Σ s.t. ux ∈ Q, ϕ(u, x, ux) = f (ux), ∀u, v ∈ Q, x ∈ Σ s.t. ux ∈ F , ϕ(u, x, v) = g(ux, v), . ∀u ∈ Q, τ (u) = fr(u) (u)

Proposition 1. The automaton A(Σ, Q, f, g, r) computes r. Proof. Let A(Σ, Q, f, g, r) = Σ, Q, ϕ, ι, τ . Let us show, by induction on |w|, that for any u ∈ Q and any w ∈ Σ ∗ , ur(w) ˙ = f (u)rA,u (w). – Let u ∈ Q: ur(ε) ˙ = r(u) and f (u)rA,u (ε) = f (u)τ (u) = r(u). – Let u ∈ Q, w ∈ Σ ∗ and x ∈ Σ. If ux ∈ Q,

f (u)rA,u (xw) = f (u)ϕ(u, x, ux)rA,ux (w) = f (ux)rA,ux (w) by definition of f ˙ uxr(w) = f (ux) by induction hypothesis f (ux) ˙ = uxr(w).

If ux ∈ Q, f (u)rA,u (xw) = f (u)



g(ux, v)rA,v (w) by definition of A

v∈Q

= f (u)



v∈Q

g(ux, v)

vr(w) ˙ by induction hypothesis f (v)

˙ by definition of g. = uxr(w) Therefore, for any u ∈ Q, ur ˙ = f (u)rA,u and in particular, r = f (ε)rA,ε = rA .



Absolute Convergence of Rational Series Is Semi-decidable

3 3.1

121

On Representation of Absolutely Convergent Rational Series Absolutely Convergent Rational Series

Let r be a series and let Γbe anon-empty subset of Σ ∗ . We say that r is convergent on Γ if the sum n≥0 w∈Γ ∩Σ n r(w) is convergent; if so, we denote the sum by r(Γ ). Let |r| be the series defined by |r|(w) = |r(w)|. We say that r is absolutely convergent if |r| is convergent. Note that when a series r is absolutely convergent, it is convergent over any Γ ⊆ Σ ∗ . We denote by A(Σ) (resp. by Arat (Σ)) the subspace of R Σ (resp. of rat R Σ) composed of the series that are absolutely convergent. Let r be a series, we denote by res(r) the following subset of Σ ∗ : res(r) = {u ∈ Σ ∗ /∃w ∈ Σ ∗ , r(uw) = 0}. For any absolutely convergent series r and any |r|(Σ ∗ ) ˙ word u ∈ res(r), we denote by u−1 r the series defined by u−1 r(w) = |r|(uΣ ∗ ) ur and we call it the residual of r associated with u. The set of all the residuals of r is denoted by Res(r). The vector subspace spanned by Res(r) is equal to LH(r). Note that for any u ∈ res(r), |u−1 r|(Σ ∗ ) = |r|(Σ ∗ ). The mapping r → |r|(Σ ∗ ) defines a norm n ||·||1 on A(Σ). Let us denote n by CH(r) the convex hull of Res(r): CH(r) = { i=1 αi u−1 r|n ∈ N, α ≥ 0, i i i=1 αi = 1, ui ∈ res(r)}. Let us denote by CCH(r), the closed convex hull of Res(r), i.e. the closure of CH(r). Note that when r ∈ Arat (Σ), || · ||1 is constant on CCH(r). In particular, CCH(r) is a compact convex set. Lemma 1. Let r ∈ Arat (Σ). Then ∀ > 0, ∃k ∈ N such that ∀s ∈ CCH(r), |s|(Σ >k ) < . In particular, ∀ > 0, ∃k ∈ N such that ∀u ∈ res(r), |r|(uΣ >k ) < |r|(uΣ ∗ ). Proof. For any integer k, let fk : CCH(r) → R be defined by fk (s) = |s|(Σ >k ). For any s, t ∈ CCH(r), we have |fk (s)−fk (t)| ≤ ||s−t||1 . Hence, fk is continuous for any k. Moreover, limk→∞ fk (s) = 0 for any s ∈ CCH(r). Since CCH(r) is compact, (fk ) converges uniformy to 0: for any  > 0, there exists K ≥ 0 s.t. for any k ≥ K and any s ∈ CCH(r), |fk (s)| < . Apply the result to s = u−1 r and 

/|r|(Σ ∗ ) to obtain the second result. Lemma 2. Let r ∈ Arat (Σ) and let d = dim(LH(r)). For all  > 0, there exists an integer N such that for any u∈ res(r), there exists v1 , . . . , vd∈ res(r)∩Σ ≤N and α1 , . . . , αd > − such that 1≤i≤d αi < 1 +  and u−1 r = 1≤i≤d αi vi−1 r. Proof. Suppose that there exists  > 0 such that for any integer n,there exists r = di=1 αi vi−1 r un ∈ res(r) such that for any v1 , . . . , vd ∈ res(r) ∩ Σ ≤n , u−1 d n implies that there exists an index i s.t. αi ≤ −, or i=1 αi ≥ 1 + . Let nk be a subsequence such that u−1 nk r converges to an absolutely convergent series s ∈ CCH(r). −1 Now, let v1 , . . . , vd−1 be such that v1−1 r, . . . , vd−1 r, s form a basis of LH(r). −1 −1 −1 r + αd,k s. Since u−1 For any integer k, let unk r = α1,k v1 r + . . . + αd−1,k vd−1 nk r converges to s, αi,k converges to 0 for i = 1, . . . , d − 1 and αd,k converges to 1

122

R. Bailly and F. Denis

when k tends to infinity. Therefore, there should exist an integer K such that for any k ≥ K, each coefficient of this combination is strictly greater that −, and the sum of all its coefficient is strictly lower than 1+, which is contradictory.  3.2

A Particular Representation of Absolutely Convergent Rational Series

Let A = Σ, Q, ϕ, ι, τ  be an MA. Let us denote by |A| the MA defined by |A| = Σ, Q, |ϕ|, |ι|, |τ |. Lemma 3. |rA | ≤ r|A| . Hence, if r|A| is convergent, then rA is absolutely convergent. Proof. Indeed,   ι(q)ϕ(q, w, q  )τ (q  )| ≤ |ι(q)ϕ(q, w, q  )τ (q  )| = r|A| (w). |rA (w)| = | q,q ∈Q



q,q ∈Q

Lemma 4. Let A = Σ, Q, ϕ, ι, τ  be a MA. Suppose that ϕ takes only non negative values and that there exists an integer k such that for any state q, ϕ(q, Σ k , Q) < 1. Then, the series r|A| is convergent. Proof. Let R = sup{ϕ(q, Σ h , Q)|q ∈ Q, h < k} and ρ = sup{ϕ(q, Σ k , Q)|q ∈ Q}. From the hypothesis, ρ < 1. state q and any integers n > 0 and 0 ≤ h < k, ϕ(q, Σ nk+h , Q) =  Since for any (n−1)k+k  ϕ(q, Σ , q )ϕ(q  , Σ h , Q), it can easily be shown by induction on n q ∈Q nk+h , Q) ≤ Rρn . that ϕ(q, Σ Let I = Sup{|ι(q)| for q ∈ Q} and T = Sup{|τ (q)| for q ∈ Q}. We have |rA |(Σ nk+h ) ≤



|ι(q)|ϕ(q, Σ nk+h , q  )|τ (q  )| ≤ IT

q,q  ∈Q

Therefore, |rA |(Σ ∗ ) =



ϕ(q, Σ nk+h , Q) ≤ IT R|Q|ρn

q∈Q

 k−1  n≥0 h=0

|rA |(Σ nk+h ) ≤ IT R|Q|k

 h≥0

ρn =

IT R|Q|k . 1−ρ

Note that if A is prefixial, there exists a unique state q such that ι(q) = 0. So we can take R = sup{ϕ(ε, Σ h , Q)|q ∈ Q, h < k} and we have |rA |(Σ nk+h ) ≤ IT Rρn . Rk 

and |rA |(Σ ∗ ) ≤ IT 1−ρ . Theorem 1. Let r ∈ Arat (Σ). Let ρ < 1. There exists an integer n, and a prefixial MA A = Σ, Q, ϕ, ι, τ  that computes r and such that ∀u ∈ Q, |ϕ|(u, Σ n , Q) < ρ. Hence, the series r|A| is convergent. Proof. Let r ∈ Arat (Σ) and let d = dim(LH(r)). Let ρ < 1 and let ε = ρ/16. ≥k ) From Lemma 1, let k be an integer such that ∀u ∈ res(r), |r|(uΣ |r|(uΣ ∗ ) < . Let  −1  = (d|Σ|) . From Lemma 2, let N > k be an integer such that for all u ∈

Absolute Convergence of Rational Series Is Semi-decidable

123

α1 v −1 r = x ε

y

u

ϕ(u, x, ux)

z

∗

w2

w1

|r|(vΣ ) ∗) × |r|(vxΣ d α wi−1 r i i=1

α2 v

ux

ϕ(u, x, ux)=

wd

|r|(uxΣ∗ ) |r|(uΣ∗ )

αd ΣN +k

ΣN

Fig. 1. Automaton built in the proof of Theorem 1

res(r), there exists vu,1 , . . . , vu,d ∈ res(r) ∩ Σ ≤N and αu,1 , . . . , αu,d > − such d d −1 r. that i=1 αu,i < 1 +  ≤ 2 and u−1 r = i=1 αu,i vu,i N +k ∩ res(r). Let f : Q → R be defined by f (ε) = 1 and ∀ux ∈ Let Q = Σ ∗ ) ∗ Q, f (ux) = |r|(uxΣ |r|(uΣ ∗ ) where u ∈ Σ and x ∈ Σ. One can easily show that f (u) = |r|(uΣ ∗ )/|r|(Σ ∗ ). Let F = {ux|u ∈ Q, x ∈ Σ, ux ∈ Q}. For any ux ∈ F ∩ res(r), there exist coefficients (αux,v  )v∈Σ ≤N such that (i) at most d coefficients  αux,v are not null; (ii) (ux)−1 r = v∈Σ ≤N αux,v v −1 r; (iii) αux,v > − ; (iv) v∈Σ ≤N αux,v < 1+ .   αux,v ˙ = |r|(uxΣ ∗ ) ˙ From (ux)−1 r = v∈Σ ≤N αux,v v −1 r, then uxr v∈Σ ≤N |r|(vΣ ∗ ) vr. ∗

) Let g : Q × F → R be defined by g(ux, v) = αux,v |r|(uxΣ |r|(uΣ ∗ ) if ux ∈ F ∩ res(r) and 0 otherwise. One can check that the conditions on f and g stated in Section 2.2 are satisfied. (see Fig. 1) From the proposition 1, the MA A(Σ, Q, f, g, r) = Σ, Q, ϕ, ι, τ  computes r. Let us list below some properties of A:

1. ∀u ∈ Q ∩ Σ |r|(Σ ∗ ). ≤N

be such that for any ux ∈ For any integers N and k, let D : Σ N +k+1 → 2Σ N +k+1 , {vr|v ˙ ∈ D(ux)} forms a basis of LH(r). In particular, |D(ux)| = d = Σ dim(LH(r)). Given N , k, D and fn , there exists a unique function g : Σ N +k+1 × Σ ≤N → R such that g(ux, v) = 0 if v ∈ D(ux) and such that A(Σ, Q, fn , g, r) computes r (see Proposition 1). Let us denote it by A(N, k, D, fn ). Now given ρ < 1, there exists k0 , N0 such that ∀N > N0 , ∀k > k0 there exists n and D such that A = A(N, k, D, fn ) satisfies:

Absolute Convergence of Rational Series Is Semi-decidable

127

– ϕ|A| (u, Σ 2k , Q) < ρ – ∀u ∈ Σ N +k , |τ (u)| < T Proof. By considering the proof of Theorem 1, it can be proved that there exists integers N0 and k0 such that ∀N > N0 , ∀k > k0 there exists D : Σ N +k+1 → ≤N 2Σ such that A = A(N, k, D, f ) satisfies ϕ|A| (u, Σ 2k , Q) < ρ/2 and ∀u ∈ Σ N +k , |τ (u)| ≤ |r|(Σ ∗ ). Since ϕ|A(N,k,D,fn )| (u, Σ 2k , Q) and |τ|A(N,k,D,fn )| (u)| are continuous relatively to the transition coefficients, there exists an integer n such that the conclusion holds. 

Proposition 3. Let r ∈ Arat (Σ). Let A = {A(N, k, D, fn )/N, k, n ∈ N, D ∈ P(Σ N )}. Then inf(r|A| (Σ ∗ ))A∈A = |r|(Σ ∗ ). Proof. Let N0 and k0 be such as in Lemma 5. We define a sequence (Az )z∈N of automata: – Nz = N0 + z, kz = k0 – ∀z, nz and Dz are such as in Lemma 5, Az = A(Nz , kz , Dz , fnz ). As Nz grows, r|Az | converges pointwisely to |r|. We have τz ∞ < T by construction. We have R = suphn ∗ ∗ fore |r|(Σ  ) < T ρn/2k0 −1 . Now, |r|Az | (Σ w∈Σ ∗ |r|Az | (w) −  ) − |r|(Σ )| ≤  |r|(w)| ≤ w∈Σ ≤Z1 |r|Az | (w) − |r|(w)| + w∈Σ >Z r (w) + w∈Σ >Z1 |r|(w). 1 |Az | such that both r (w) < /3 and For  > 0, one can find Z >Z 1 1 |Az | w∈Σ  |r|(w) < /3. Finally, as r converges pointwisely to |r|(w), one >Z |Az | 1 w∈Σ  can find Z2 such that |r (w) − |r|(w)| < /3, and we can ≤Z |Az | 1 w∈Σ conclude. 

Proposition 4. Let AZ be an enumeration of the set {A(N, k, D, n)/N, k, n ∈ N, D ∈ P(Σ N )}. Let G0 = r|A(N0 ,k0 ,D0 ,fn0 )| (Σ ∗ ). Let Gz = r|Az | (Σ ∗ ) if it exists, and if Gz < Gz−1 , Gz = Gz−1 otherwise. Then limz→∞ Gz = |r|(Σ ∗ ). Proof. Straightforward from Proposition 3.



Theorem 3. Let r ∈ Arat (Σ). For any ε > 0, it is possible to compute an ∗ ) − |r|(Σ ∗ ) < ε. If the L1 -distance ∗ ) of |r|(Σ ∗ ) such that |r|(Σ estimate |r|(Σ d of two rational series r and s is finite, for any ε > 0, it is possible to compute an estimate dˆ of d such that |dˆ − d| < ε. Proof. Using Proposition 4, find Gz and n such that Gz − |r|(Σ ≤n ) < 2ε. For the second part, apply the result to r − s. 

6

Conclusion

In this paper, we have proved that it is semi-decidable whether a rational series is absolutely convergent. Then, given an absolutely convergent rational series

128

R. Bailly and F. Denis

r, we have provided an algorithmic way to estimate the sum |r|(Σ ∗ ) to any accuracy rate. We do not know whether Arat (Σ) is decidable. We conjecture that it should be decided that a rational series r is not absolutely convergent when ρ|r| > 1 but the case ρ|r| = 1 is likely to be difficult. We intend to study the links between the spectral radius we have defined and the joint or generalized spectral radii. Finally, we are currently looking for more efficient algorithms and heuristics than those we have described to approximate the L1 distance of two rational series, even if there is no hope to find efficient algorithms in the worst case.

References 1. Berstel, J., Reutenauer, C.: Noncommutative Rational Series With Applications. Cambridge University Press, Cambridge (2008) 2. Salomaa, A., Soittola, M.: Automata: Theoretic Aspects of Formal Power Series. Springer, Heidelberg (1978) 3. Denis, F., Esposito, Y.: On rational stochastic languages. Fundamenta Informaticae 86(1-2), 41–77 (2008) 4. Denis, F., Esposito, Y., Habrard, A.: Learning rational stochastic languages. In: Lugosi, G., Simon, H.U. (eds.) COLT 2006. LNCS, vol. 4005, pp. 274–288. Springer, Heidelberg (2006) 5. Lyngsø, R.B., Pedersen, C.N.S.: The consensus string problem and the complexity of comparing hidden markov models. J. Comput. Syst. Sci. 65(3), 545–569 (2002) 6. Cortes, C., Mohri, M., Rastogi, A.: On the computation of some standard distances between probabilistic automata. In: H. Ibarra, O., Yen, H.-C. (eds.) CIAA 2006. LNCS, vol. 4094, pp. 137–149. Springer, Heidelberg (2006) 7. Cortes, C., Mohri, M., Rastogi, A.: Lp distance and equivalence of probabilistic automata. Int. J. Found. Comput. Sci. 18(4), 761–779 (2007) 8. Theys, J.: Joint Spectral Radius: theory and approximations. PhD thesis, UCL Universit´e Catholique de Louvain, Louvain-la-Neuve, Belgium (2005)

Non-solvable Groups Are Not in  2 [REG] FO+MOD+MAJ Christoph Behle, Andreas Krebs, and Stephanie Reifferscheid WSI - University of T¨ ubingen, Sand 13, 72076 T¨ ubingen, Germany {behlec,krebs,reiffers}@informatik.uni-tuebingen.de Abstract. Motivated by the open question whether TC0 = NC1 we consider the case of linear size TC0 . We use the connections between circuits, logic, and algebra, in particular the characterization of TC0 in terms of finitely typed monoids. Applying algebraic methods we show that the word problem for finite non-solvable groups cannot be described by a FO+MOD+MAJ[REG] formula using only two variables. This implies a separation result of FO[REG]-uniform linear TC0 from linear NC1 .

1

Introduction

An outstanding problem in circuit complexity is that of understanding the relation of the complexity classes ACC0 , TC0 and NC1 . While the containment ACC0 ⊆ TC0 ⊆ NC1 is long known, attempts for separation results have had only limited success. One strategy for attacking these problems is to use the strong connection between circuit classes, logic, and algebra exhibited in [1] and [2]. Since in the general case an answer to these questions seems to be out of reach, the research has concentrated on more restricted settings, which also correspond to meaningful restrictions in logic and algebra. For example restricting the uniformity of circuit classes to a set of predicates yields logic classes with the same set of predicates [1,3], or restricting to linear size circuits corresponds to logic with only two variables [4]. On the algebraic side two-variable logic using only the order predicate corresponds to weakly iterated block products [5,6,7] of suitable monoids. Analogous results in the case of linear size TC0 , denoted by LTC0 , are shown in [8]. Extending the algebraic characterization of LTC0 we obtain a class powerful enough to contain FO+MOD+MAJ2 [REG] and FO[REG]-uniform LTC0 , as well as FO[REG]-uniform linear size ACC0 . The main result of this paper is that the word problem of any finite non-solvable group cannot be recognized by this class and is hence not in FO[REG]-uniform LTC0 , while it can be recognized by linear FO[REG]-uniform NC1 . The motivation for such a result is given by the result of Barrington [9] that the word problem of any finite non-solvable group is complete for NC1 , thus a proof that the word problem of a non-solvable group is not in TC0 would immediately yield a separation result of TC0 from NC1 . Limitating TC0 circuits to linear size is in this case not as severe as it might seem. By the result of Allender and Kouck´ y [10] any superlinear lower bound for the word problem of the S5 (a non-solvable group), would separate TC0 from A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 129–140, 2009. c Springer-Verlag Berlin Heidelberg 2009 

130

C. Behle, A. Krebs, and S. Reifferscheid

NC1 . Although our motivation is the separation of circuit classes, we choose an algebraic approach, since groups are algebraic objects. This allows us to exploit concepts like commutators and commutativity in our proofs.

2

Preliminaries

As usual N = {1, 2, 3, . . .} denotes the natural numbers whereas Z stands for all positive and integers. Further we denote by Z+ , Z− 0 the partition of Z into the  non positive integers respectively. For a Cartesian product M = i∈I Mi the projection onto the i-th component is denoted by πi (M ). Throughout this paper we use Σ for a finite alphabet and a, b for elements of Σ. Moreover, the length of a word w in Σ ∗ is denoted by |w|. Logic. We give a short introduction following the notation of Straubing [11]. The reader familiar with this topic can skip this part and proceed to the definition of the extended majority quantifier. First we define the syntactic structure of a formula. A numerical predicate of arity c consists of a symbol Pic and a subset of Nc+1 , the interpretation. To ease notation we will identify a numerical predicate with its symbol and use Pic , or just Pi if the arity is clear, when referring to a predicate. Let V be a set of variables and x, x1 , . . . , xc ∈ V. The atomic formulas consist either of Pic (x1 , . . . , xc ) for a numerical predicate Pic or Qa (x) for a ∈ Σ, x ∈ V. The set of all first order formulas, denoted by FO, is defined recursively as follows: Every atomic formula is a formula and if φ and ψ are formulas then φ ∧ ψ, φ ∨ ψ, and ¬φ are formulas. Furthermore for a formula φ and a variable x also ∃x φ and ∀x φ are formulas. For the class FO+MOD we admit the modulo quantifier Modrp x φ, 0 ≤ r < p. The notions of bound and free variables are defined as usual and we will write φ(x) to indicate that x is a free variable occurring in φ. We define the semantics of logic formulas using V-structures. Let V be a finite V2 ) . . . (wn , Vn ) ∈ set of variables, a V-structure is a string w = (w1 , V1 )(w2 ,  n (Σ × 2V )∗ , where the Vi , 1 ≤ i ≤ n are pairwise disjoint and i=1 Vi = V. One can imagine a V-structure as a word with variables pointing to fixed positions. For an alphabet Σ and a set of free variables V we denote the set of all Vstructures by Σ ∗ ⊗ V. We use wx=i to denote a V-structure such that x ∈ Vi . Let φ be a formula and w be a V-structure where V contains all free variables of φ. We define now when w models φ, written w |= φ. w |= Qa (x) iff there exists a letter (a, Vj ) in w with x ∈ Vj . For n = |w| we set w |= Pic (x1 , . . . , xc ) iff (n, x1 , . . . , xc ) is contained in the interpretation of Pic . Further w |= φ ∧ ψ (w |= φ ∨ ψ) iff w |= φ and w |= ψ (w |= φ or w |= ψ) and w |= ¬φ iff w is not a model for φ. Finally we define when w |= ∃x φ (w |= ∀x φ). If x is not contained in one of the Vj then w |= ∃x φ (w |= ∀x φ) iff there exists some i, 1 ≤ i ≤ |w| (iff for all i, 1 ≤ i ≤ |w|) (w1 , V1 )(w2 , V2 ) . . . (wi , Vi ∪ {x}) . . . (wn , Vn ) |= φ. Else if x is contained in on of the Vj we remove x from Vj and proceed as in the case if it is free. Likewise w |= Modrp x φ iff the number of positions that wx=i |= φ is congruent to r modulo p.

 2 [REG] Non-solvable Groups Are Not in FO+MOD+MAJ

131

The Extended Majority Quantifier. In addition to these well known quan introduced in [8]. The tifiers we consider the extended majority quantifier Maj syntax for the extended majority quantifier is as follows: let φ1 , . . . , φc be formu xφ1 , . . . , φc is a formula. The semantic meaning of this formula las, then Maj  1 if wx=i |= φj  x φ1 , . . . , φc ⇔ 0 < n c . is given by w |= Maj i=1 j=1 −1 otherwise In this paper we use the the common numerical predicates: x < y is true if x points to a position before y, the successor predicate x = y + 1, also referred as succ, is defined by {(n, i, i + 1) ⊆ N × N × N | i < n}. The modulo predicate modp (x) is defined by the set {(n, i) ⊆ N × N | i ≤ n and i ≡ 0 mod p} and last(x) by {(n, n) | n ∈ N}. A c-ary numerical predicate P is called regular iff the language LP = {w ∈ {a}∗ ⊗ {x1 , . . . xc } | w |= P (x1 , . . . xc )} is regular. We denote by REG the set of regular predicates. A numerical predicate P is said to be first order constructible from a set of numerical predicates P if there exists a FO[ n and u is a factor of v. Then u is a suffix of v.

254

J. Brzozowski, J. Shallit, and Z. Xu

Suffix-freeness Theorem 10. There exists a class of languages accepted by DFA’s with O(n) states, such that the smallest witness to the lack of suffix-freeness is of size Ω(n2 ). Proof. Let L = bb(an )+ ∪ b(an+1 )+ . This language is accepted by a DFA with 2n + 5 states. However, the shortest witness to the lack of suffix-freeness (ban(n+1) , bban(n+1) ) has size n2 + n + 2.

3.4

Subword-Convexity

We now turn to subword properties. First, we recall some facts about the pumping lemma. If w = a1 · · · am with ai ∈ Σ for 1 ≤ i ≤ m, we write w[i, j] for the factor ai · · · aj . Assume that M = (Q, Σ, δ, q0 , F ) is an n-state DFA, m ≥ n, let q ∈ Q, and consider the state sequence S(q, w) = (δ(q, w[1, 0]), . . . , δ(q, w[1, m])). We know that some state in S(q, w) must appear more than once, because there are only n distinct states in M . Let δ(q, w[1, i]) be the first state that appears more than once in S, and let x = w[1, i]. Moreover, let δ(q, w[1, j]) be the first state in S(q, w) equal to δ(q, w[1, i]), and let y = w[i + 1, j]. Finally, let z = w[j + 1, m]. Then w = xyz, where |xy| ≤ n, |y| > 0, and |z| ≥ m − n, and δ(q, x) = δ(q, xy). By the pumping lemma, xy ∗ z ⊆ L. By the definition of x and y, all the states in the sequence S(q, w[1, j − 1]) are distinct. For a word w with |w| = m ≥ n, we refer to the factorization w = xyz as the canonical factorization of w with respect to q. Subword-closure. Here v  w means v is a subword of w. If L = L(M ) is not subword-closed, then (v, w) is a witness if w ∈ L, v ∈ L, and v  w. Lemma 1. Let M be a DFA with n ≥ 2 states such that L(M ) is not subwordclosed. For any witness (v, w), there exists a witness (v  , w ) with |w | ≤ n and w  w. Proof. We will show that, for any witness (v, w) with |w| ≥ n + 1, we can find a witness (v  , w ) with |w | < |w| and w  w. The lemma then follows. Suppose that (v, w) is a minimal witness, and |w| = m ≥ n + 1. Then the canonical factorization of w is w = xyz, where |xy| ≤ n, |y| > 0, and |z| ≥ m − n > 0. If there is a z  such that z   z and xyz  ∈ L, then xz  ∈ L, since xyz  and xz  lead to the same state in M . Then (xz  , xz) is a witness with |xz| < |w| and xz  w. Thus we can assume that z   z implies xyz  ∈ L.

(1)

Since v  w = xyz, we can write v = vx vy vz , where vx  x, vy  y, and vz  z. Clearly, v  xyvz . If vz = z, then by (1), we have xyvz ∈ L, and (v, xyvz ) is a witness with |xyvz | < |w| and xyvz  w. Thus we may assume that our witness has the form (vx vy z, xyz).

Decision Problems for Convex Languages

255

In the particular case that z  = , (1) implies that xy ∈ L. If y  y and xy  ∈ L, then (xy  , xy) is a witness with |xy| < |w| and xyw. Thus y  y implies xy  ∈ L. Finally, if x  x and x ∈ L, then (x , x) is a witness with |x| < |w| and x  w. Thus x  x implies x ∈ L. Altogether, we may assume that all the states along the path spelling w in M are accepting. We know that the states in S = (δ(q0 , w[1, 0]), . . . , δ(q0 , w[1, |xy| − 1])) are all distinct. Also, the states in S  = (δ(q0 , vx vy z[1, 1]), . . . , δ(q0 , vx vy z[1, |z| − 1])) are all accepting and distinct; otherwise, v would not be shortest. We now claim that no state can be in both S and S  . For suppose that δ(q0 , w[1, i]) = δ(q0 , vx vy z[1, k]), for some 0 ≤ i ≤ |x|, 0 < k < |z|. Then (w[1, i]z[k + 1, |z|], xz) is a witness with |xz| < |w| and xz  w, since w[1, i] = x[1, i], and x[1, i]z[k + 1, |z|]  xz. Next, if δ(q0 , xy[1, j]) = δ(q0 , vx vy z[1, k]), for some 0 < j < |y|, 0 < k < |z|, then (xy[1, j]z[k + 1, |z|], xyz[k + 1, |z|]) is a witness with |xyz[k + 1, |z|]| < |w| and xyz[k + 1, |z|]  w, since xy[1, j]z[k + 1, |z|]  xyz[k + 1, |z|], and xyz[k + 1, |z|] ∈ L by (1). Under these conditions M must have |xy| + (|z| − 1) = |xyz| − 1 distinct accepting states, and at least one rejecting state. Hence |xyz| = |w| ≤ n and we have found a witness with the required properties.

Corollary 6. Let M be a DFA with n ≥ 2 states. If L(M ) is not subword-closed, there exists a witness (v, w) with |w| ≤ n. Furthermore, this is the best possible bound, as there exists a unary DFA with n states that achieves this bound. For n = 1, L is either ∅ or Σ ∗ , and these languages are subword-closed. Subword-freeness Lemma 2. Let M be a DFA with n ≥ 2 states such that L(M ) is not subwordfree. For any witness (u, w), there exists a witness (u , w ) with |w | ≤ 2n − 1, and w  w. Corollary 7. Let M be a DFA with n ≥ 2 states. If L(M ) is not subword-free, there exists a witness (u, w) with |w| ≤ 2n − 1. This is the best possible bound, as there exists a unary DFA with 2n − 1 states that achieves this bound. Subword-Convexity Lemma 3. Let M be a DFA with n ≥ 2 states such that L(M ) is not subwordconvex. For any witness (u, v, w), there exists a witness (u , v  , w ) with w  w, and |w | ≤ 3n − 2. Proof. We will show that, for any witness (u, v, w) with |w| ≥ 3n − 1, we can find a witness (u , v  , w ) with |w | < |w| and w  w. The lemma then follows. We assume without loss of generality that v is a shortest possible word corresponding to the given w, and u is a shortest word corresponding to v and w. First, consider the witness (u, v) to the lack of subword-closure of the language L. By Lemma 1, there exists a witness (u , v  ) to the failure of subword-closure of L such that v   v and |v  | ≤ n. Therefore we can assume that we have a witness (u, v, w) to the failure of subword-convexity such that |v| ≤ n.

256

J. Brzozowski, J. Shallit, and Z. Xu

Suppose that (u, v, w) is a minimal witness, and |w| ≥ 3n − 1. Then the canonical factorization of w is w = x1 y1 z1 , where |x1 y1 | ≤ n, |y1 | > 0, and |z1 | ≥ 2n − 1 ≥ n > 0. Consider the states p0 = δ(q0 , x1 y1 ), p1 = δ(q0 , x1 y1 z1 [1, 1]), · · · , p|z1 | = δ(q0 , x1 y1 z1 ). Since |z1 | ≥ n, there must be at least one pair (pi , pj ) of states such that pi = pj . If p0 is the state that is repeated, let i be the greatest index such that p0 = pi , and let x2 = , y2 = z1 [1, i], and z2 = z1 [i + 1, |z1 |]. If pi is the first state that is repeated, let j be the greatest index such that pi = pj , and let x2 = z1 [1, i], y2 = z1 [i + 1, j], and z2 = z1 [j + 1, |z1 |]. If δ(q0 , x1 y1 x2 y2 ), δ(q0 , x1 y1 x2 y2 z2 [1, 1]), . . . , δ(q0 , x1 y1 x2 y2 z2 ) has no repeated states, we stop. Otherwise, we apply the same procedure to z2 , and so on. In any case, eventually we reach a zk for which no repeated states exist. Then we have the factorization w = x1 y1 x2 y2 · · · xk yk zk , where x1 y1∗ x2 y2∗ · · · xk yk∗ zk ⊆ L, |x2 · · · xk zk | < n (otherwise, there would be repeated states), |yi | > 0, for i = 1, . . . , k, and k ≥ 2. For any y2  y2 , · · · , yk  yk , we have x1 y1 x2 y2 · · · xk yk zk ∈ L. Otherwise, the triple (x1 x2 · · · xk zk , x1 x2 y2 · · · xk yk zk , x1 x2 y2 · · · xk yk zk ) is a witness with |x1 x2 y2 · · · xk yk zk | < |w|, and x1 x2 y2 · · · xk yk zk  w. Since v  w, we can now write v = vx1 vy1 vx2 vy2 · · · vxk vyk vzk , where vx1  x1 , etc. If there is a yi with i ≥ 2, such that vyi = , then we can replace that yi by  in w and obtain a smaller witness. Hence each vyi must be nonempty. By the same argument, if there is a letter in yi , for i ≥ 2, that is not used in vyi , then that letter can be removed, yielding a smaller witness. Therefore yi = vyi for i = 2, . . . , k. We claim that |y2 · · · yk | < |v|; otherwise v = vy2 · · · vyk = y2 · · · yk and (u, v, x1 x2 y2 · · · xk yk zk ) is a witness with |x1 x2 y2 · · · xk yk zk | < |w|. Thus |y2 · · · yk | < |v| ≤ n, and |w| = |x1 y1 | + |x2 · · · xk zk | + |y2 · · · yk | ≤ n + (n − 1) + (n − 1) = 3n − 2.

Corollary 8. Let M be a DFA with n ≥ 2 states. If L(M ) is not subwordconvex, there exists a witness (u, v, w) with |w| ≤ 3n − 2. We do not know whether 3n−2 is the best bound. The unary language an−1 (an )∗ is accepted by a DFA with n states and has a minimal witness (an−1 , an , a2n−1 ), showing that 2n − 1 is achievable.

4 4.1

Languages Specified by Other Means Languages Specified by NFA’s

Some of our decision problems become PSPACE-complete if M is represented by an NFA. Our fundamental tool is the following classical lemma [9]: Lemma 4. Let T be a one-tape deterministic Turing machine and p(n) a polynomial such that T never uses more than p(|x|) space on input x. Then there is a finite alphabet Δ and a polynomial q(n) such that we can construct a regular expression rx in q(|x|) steps, such that L(rx ) = Δ∗ if T doesn’t accept x, and

Decision Problems for Convex Languages

257

L(rx ) = Δ∗ − {w} for some nonempty w (depending on x) otherwise. Similarly, we can construct an NFA Mx in q(|x|) steps, such that L(Mx ) = Δ∗ if T doesn’t accept x, and L(Mx ) = Δ∗ − {w} for some nonempty w (depending on x) otherwise. Theorem 11. The problem of deciding whether a given regular language L, represented by an NFA or regular expression, is prefix-convex (resp., suffix-, factor-, subword-convex), or prefix-closed (resp., suffix-, factor-, subword-closed) is PSPACE-complete. For the properties of prefix-, suffix, and factor-closed properties, this result was essentially already proved by Hunt and Rosenkrantz [10, Thm. 3.4]. The situation is different for deciding the property of prefix-freeness, suffixfreeness, etc., for languages represented by NFA’s, as the following theorem shows. This was proved by Han et al. [8] through a different approach. Theorem 12. Let M be an NFA with n states and t transitions. Then we can decide in O(n2 + t2 ) time whether L(M ) is prefix-free (resp., suffix-free, factorfree, subword-free). Minimal Witnesses for NFA’s. We have already seen that the length of the minimal witness for the lack of convexity or closure is polynomial in the size of the DFA. For the case of NFA’s, however, this bound no longer holds. Theorem 13. There is a class of NFA’s with O(n) states such that the shortest witness to the lack prefix-convexity (resp., suffix-, factor-, subword-convexity) or prefix-closure (resp., suffix-, factor-, subword-closure) is of length 2Ω(n) . Theorem 14. There exists a class of languages, accepted by NFA’s with O(n) states and O(n) transitions, such that the minimal witness for the lack of prefixfreeness is of length Ω(n2 ). For the lack of subword-freeness, we cannot improve the bound we obtained for DFA’s in Corollary 7, as the proof we presented there also works for NFA’s. 4.2

Languages Specified by Context-Free Grammars

If L is represented by a context-free grammar, then the decision problems corresponding to convex and closed languages become undecidable. This follows easily from a well-known result that the set of invalid computations of a Turing machine is a CFL [11, Lemma 8.7, p. 203]. Similarly, the decision problems corresponding to the properties of prefix-free, suffix-free, and factor-free become undecidable for CFL’s, as shown by J¨ urgensen and Konstantinidis [12, Thm. 9.5, p. 581]. However, testing subword-freeness is still decidable for CFL’s: Theorem 15. There is an algorithm that, given a context-free grammar G, will decide if L(G) is subword-free.

258

5

J. Brzozowski, J. Shallit, and Z. Xu

Conclusions

We have shown that we can decide in O(n3 ) time whether a language specified by a DFA is prefix-, suffix-, factor-, or subword-convex, and that the corresponding closure and freeness properties can be tested in O(n2 ) time. If L is specified by an NFA or a regular expression, these problems are PSPACE-complete.

Acknowledgments This research was supported by the Natural Sciences and Engineering Research Council of Canada.

References 1. Thierrin, G.: Convex languages. In: Nivat, M. (ed.) Automata, Languages, and Programming, pp. 481–492. North-Holland, Amsterdam (1973) ´ 2. Ang, T., Brzozowski, J.: Continuous languages. In: Csuhaj-Varj´ u, E., Esik, Z. (eds.) Proc. 12th International Conference on Automata and Formal Languages, pp. 74– 85. Computer and Automation Research Institute, Hungarian Academy of Sciences (2008) 3. Berstel, J., Perrin, D.: Theory of Codes. Academic Press, New York (1985) 4. Han, Y.S.: Decision algorithms for subfamilies of regular languages using state-pair graphs. Bull. European Assoc. Theor. Comput. Sci. (93), 118–133 (2007) 5. Brzozowski, J.A., Shallit, J., Xu, Z.: Decision problems for convex languages (preprint, 2008), http://arxiv.org/abs/0808.1928 6. B´eal, M.P., Crochemore, M., Mignosi, F., Restivo, A., Sciortino, M.: Computing forbidden words of regular languages. Fund. Inform. 56, 121–135 (2003) 7. de Luca, A., Varricchio, S.: Some combinatorial properties of factorial languages. In: Capocelli, R. (ed.) Sequences, pp. 258–266. Springer, Heidelberg (1990) 8. Han, Y.S., Wang, Y., Wood, D.: Infix-free regular expressions and languages. Internat. J. Found. Comp. Sci. 17, 379–393 (2006) 9. Aho, A., Hopcroft, J., Ullman, J.: The Design and Analysis of Computer Algorithms. Addison-Wesley, Reading (1974) 10. Hunt III, H.B., Rosenkrantz, D.J.: Computational parallels between the regular and context-free languages. SIAM J. Comput. 7, 99–114 (1978) 11. Hopcroft, J.E., Ullman, J.D.: Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, Reading (1979) 12. J¨ urgensen, H., Konstantinidis, S.: Codes. In: Rozenberg, G., Salomaa, A. (eds.) Handbook of Formal Languages, vol. 1, pp. 511–607. Springer, Heidelberg (1997)

On a Family of Morphic Images of Arnoux-Rauzy Words Michelangelo Bucci and Alessandro De Luca Dipartimento di Matematica e Applicazioni “R. Caccioppoli” Universit` a degli Studi di Napoli Federico II, via Cintia, Monte S. Angelo 80126 Napoli, Italy {micbucci,alessandro.deluca}@unina.it

Abstract. In this paper we prove the following result. Let s be an infinite word on a finite alphabet, and N ≥ 0 be an integer. Suppose that all left special factors of s longer than N are prefixes of s, and that s has at most one right special factor of each length greater than N . Then s is a morphic image, under an injective morphism, of a suitable standard Arnoux-Rauzy word.

1

Introduction

Factor complexity is a common theme in the combinatorial analysis of finite and infinite words. Being the function counting distinct blocks (factors) of each length, it is one of the most natural measures of complexity of a word. A famous theorem by Morse and Hedlund [1] characterizes ultimately periodic sequences as the ones having bounded complexity. Sturmian words have the lowest possible unbounded complexity (n + 1 factors of each length n). They make up one of the most studied family of infinite words, not just because of their theoretical interest (see [2] for a general introduction, or [3] for a recent survey). From the definition, it follows that Sturmian words are on a binary alphabet, and have exactly one left special factor of each length n (a factor is left special if it is a suffix of at least two distinct factors of length n + 1). As is well known, a first natural generalization of Sturmian words for alphabets with an arbitrary number of letters was introduced by Arnoux and Rauzy [4]. An infinite word s is Arnoux-Rauzy (or strict episturmian, see below) if it is recurrent (i.e., all factors of s occur infinitely often) and it has exactly one left special factor and one right special factor per length, that appear in s immediately preceded (resp. followed) by all letters occurring in s. More detailed definitions will be given in Sect. 2. A remarkable property of Sturmian words, shared by Arnoux-Rauzy words, is their closure under reversal : if w = a1 a2 · · · an is a factor of an Arnoux-Rauzy ˜ = an an−1 · · · a1 is a factor of s too. word s with ai ∈ A for i = 1, . . . , n, then w This led Droubay, Justin, and Pirillo [5] to a generalization: an infinite word is episturmian if it has at most one left special factor per length, and is closed A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 259–266, 2009. c Springer-Verlag Berlin Heidelberg 2009 

260

M. Bucci and A. De Luca

under reversal. Episturmian words are recurrent, but have no restriction on the number of letters immediately preceding left special factors. Thus the family of episturmian words strictly contains the one of Arnoux-Rauzy words. The class of ϑ-episturmian words is a further generalization, recently introduced in [6] by substituting the reversal operator with any involutory antimorphism ϑ of A∗ . Generalizing even more, by requiring the condition on special factors only for sufficient lengths, ϑ-words with seed are obtained (see [6]). All such words have a standard counterpart, where the unique left special factors correspond to prefixes of the infinite word. For instance, a ϑ-standard word with seed is any infinite word s which is closed under ϑ and such that any sufficiently long left special factor of s is a prefix of it. For all the above classes, standard words are good representatives, in the sense that an infinite word s belongs to one of such classes if and only if s has the same set of factors as some standard word of that class (see [5,6]). Our main result shows that, in the standard case, even when the further step of dropping the “closure under some ϑ” requirement is made, the large class of words thus obtained retains a strong link with Arnoux-Rauzy words. More precisely, we will prove the following. Theorem 1. Let s ∈ Aω satisfy the following two conditions for all n ≥ N , where N ≥ 0: 1. any left special factor of s having length n is a prefix of s, 2. s has at most one right special factor of length n. Then there exists B ⊆ alph(s) and a standard Arnoux-Rauzy word t ∈ B ω such that s is a morphic image (under an injective morphism) of t. In the next section we shall give all the formal definitions and preliminary results needed for our proof, which will be given in Sect. 3. For more basics about combinatorics on words, we refer to [7]. For more details on episturmian words and their generalizations, see [3,5,8,9,6,10,11].

2

Basic Definitions and Results

In the following, A will denote a finite alphabet, A∗ the free monoid of words over A, and Aω the set of infinite words over A. The identity element of A∗ is the empty word ε. Let s be a finite or infinite word. The set of letters occurring in s is denoted by alph(s). A factor of s is any finite word w such that s = uwv for suitable words u, v; if u (resp. v) is the empty word we call w a prefix (resp. suffix ) of s. A border of s ∈ A∗ is a word which is both a prefix and a suffix of s. If s is nonempty, we denote by sf its first letter, and if s is also finite we denote by s its last letter1 . With Fact(s), Pref(s), and Suff(s) we denote respectively the set 1

This notation should not be confused with powers of a word; no such power occurs in this paper.

On a Family of Morphic Images of Arnoux-Rauzy Words

261

of factors, prefixes, and suffixes of s. The factor complexity of s is the function cs : IN → IN defined by cs (n) = #(An ∩ Fact(s)) for all n ≥ 0. We remark that the complexity of an infinite word s is a nondecreasing function. Let w ∈ Fact(s). A factor v of s is called a right (resp. left ) extension of w in s if w is a proper prefix (resp. suffix) of v. If |w| = n, the right (resp. left ) degree of w in s is the number of its distinct right (resp. left) extensions of length n + 1. For all n ≥ 0, any factor of s of length n + 1 is uniquely determined by its first letter and by its suffix of length n, or by its last letter and by its prefix of length n. An immediate consequence is the following well-known identity:   deg− (w) = cs (n + 1) = deg+ (w) , (1) w∈Fs (n)

w∈Fs (n) −

+

in which the operators deg and deg denote the left and right degree respectively, and Fs (n) = An ∩ Fact(s). We recall that w is called a right (resp. left ) special factor of s if its right (resp. left) degree is at least 2, i.e., if there exist two distinct letters a and b such that wa and wb (resp. aw and bw) are factors of s. If a factor of s is both left and right special, then it is called bispecial. A complete return to w in s is any factor of s containing exactly two occurrences of w, one as a prefix and the other as a suffix. If z = vw is a complete return to w, then v is called a return word to w (cf. [12]). An infinite word s is recurrent if each of its factors has infinitely many occurrences in s; it is uniformly recurrent if the gaps between consecutive occurrences of any factor are bounded. Equivalently, s is uniformly recurrent if for all factors w there are finitely many distinct return words to w in s. Given any prefix p of an infinite word s, there exists a unique factorization of s by means of the return words to p in s. By mapping each return word to a different letter of a suitable alphabet, and then applying such a map to s thus factorized, we obtain a derivated word of s with respect to p (cf. [12]). Clearly, s is a morphic image of its derivated words. The following simple lemma is the first basic ingredient needed for our main result. Lemma 1. Let s be an infinite word such that any sufficiently long left special factor of s is a prefix of it. Then s is recurrent. Proof. By contradiction, suppose there exists a factor w of s having only finitely many occurrences in s, and let λw be the prefix of s ending with the rightmost occurrence of w in s. Then all prefixes of s from length |λw| onward do not reoccur in s, and so have left degree 0. We claim that this implies that s has also at least one left special factor for each length n ≥ |λw|. Indeed, for all such n the left sum in (1) has cs (n) = # Fs (n) terms. Since the prefix has left degree 0, there must be a term greater than 1 in order to have cs (n + 1) ≥ cs (n) (which is true as s is infinite). By definition, a factor with left degree greater than 1 is a left special factor. For sufficiently large n, such a factor should be a prefix of s by hypothesis. We have reached a contradiction.  

262

M. Bucci and A. De Luca

An infinite word s is periodic if it can be written as s = vvv · · · = v ω for some finite word v. An ultimately periodic word is an infinite word of the form uv ω for some u, v ∈ A∗ . As is well known (see for instance [13, Lemma 1.4.4]), a recurrent ultimately periodic word is necessarily periodic. We need one of the most well-known and useful restatements of the theorem of Morse and Hedlund (cf. [1, Theorem 7.3]): Theorem 2. An infinite word s is ultimately periodic if and only if cs (n) = cs (n + 1) for some n ≥ 0. As a consequence of Lemma 1, we obtain the following specialization. Proposition 1. An infinite word s is (purely) periodic if and only if it has no left special factor of some length n. Proof. If s = pω with p ∈ A∗ , then s has no left special factors of length |p|. Conversely, assume that s has no left special factor of length n. This implies #(An ∩ Fact(s)) = #(An+1 ∩ Fact(s)) , so that by Theorem 2, s is ultimately periodic. Clearly s has no left special factor of any length k ≥ n, thus it trivially satisfies the hypothesis of Lemma 1. Therefore s is recurrent, and hence periodic.   The following proposition was proved in [10, Lemma 7] under different hypotheses. We report an adapted proof for the sake of completeness. Proposition 2. Let s be a recurrent aperiodic infinite word. Then every factor w of s is contained in some bispecial factor of s. Proof. Since s is recurrent, we can consider a complete return z to w in s. Writing z = vw, it cannot happen that the factor w is always preceded by v in s, otherwise s would be periodic. Thus some suffix of z of length at least |w| must be a left special factor of s. Let x ∈ A∗ be of minimal length such that xw is a left special factor of s. Such a word is trivially unique, and w is always preceded in s by x. In a similar way, there exists a unique y ∈ A∗ of minimal length such that wy is right special in s, and w is always followed by y. Since xw is left special in s and xw is always followed by y one has that xwy is also left special. Similarly, since wy is right special and always preceded by x, xwy is right special. Hence every factor w of s is contained in some bispecial factor W = xwy of s.   A recurrent word s is an Arnoux-Rauzy word if it has exactly one left special factor and one right special factor of each length, all of degree # alph(s). It is natural to extend this definition to the case of a unary alphabet A = {a}; the word aω is considered an Arnoux-Rauzy word, since it has a unique factor of each length, clearly not special but of degree 1 = #A. Thus we can reformulate the definition as follows: a recurrent word s is Arnoux-Rauzy if for all n ≥ 0, all factors of length n have minimum left degree (i.e. 1) except one whose left degree is maximum(# alph(s)), and the same

On a Family of Morphic Images of Arnoux-Rauzy Words

263

occurs for right degrees (but the two special factors may be different). By (1), this implies cs (n + 1) = cs (n) + alph(s) − 1 and then, as cs (0) = 1, cs (n) = 1 + (# alph(s) − 1)n for all n ∈ IN . Arnoux-Rauzy words are uniformly recurrent (cf. [5]); this was part of the definition in [4]. An Arnoux-Rauzy word s is standard if its left special factors are prefixes of s. Example 1. A well-known standard Arnoux-Rauzy word is the so-called Tribonacci (or Rauzy) word τ = abacabaabacababacabaabacabacabaabacabab · · · which can be obtained as a fixed point of the morphism a → ab, b → ac, c → a (see [4,5]). Remark 1. In order to show that a given infinite word s is a standard ArnouxRauzy word, it is sufficient to prove the following two conditions: 1. s has exactly one factor of right degree # alph(s) for each length, 2. every left special factor of s is a prefix of it. Indeed, under such hypotheses s is recurrent by Lemma 1. Moreover, in view of (1), by the first condition we derive cs (n + 1) ≥ # alph(s) + cs (n) − 1

(2)

for all n ≥ 0; by condition 2, all factors which are not prefixes have left degree 1, so that equality holds in (2) and there is one factor of left degree # alph(s). In conclusion, all factors of length n have left degree 1, except one which has left degree # alph(s), and the same occurs for right degrees, for all n; hence s is an Arnoux-Rauzy word (standard by condition 2).

3

Proof of Theorem 1

Suppose first that s has no left special factor of some length n. Then s is periodic by Proposition 1, so that it is trivially a morphic image of xω for any x ∈ alph(s). Now let us assume that s has at least one left special factor of each length – exactly one, from length N on. By Lemma 1, s is recurrent, so that by Proposition 2 it has infinitely many bispecial factors, which we denote by W0 = ε, W1 , . . . , Wn , . . ., where |Wi | ≤ |Wi+1 | for all i ≥ 0. Let j be the least index such that |Wj | ≥ N . Since prefixes (resp. suffixes) of left (resp. right) special factors are left (resp. right) special themselves, by conditions 1 and 2 it follows that Wi is a border of Wi+1 for all i ≥ j, and the sequence whose n-th term is the (right) degree of Wn for all n ≥ j is then non-increasing. Hence there exists k ≥ j such that Wn has the same degree of Wk for all n ≥ k, that is, the above considered sequence is constant from its k-th term on. We set B = {x ∈ A | Wk x ∈ Fact(s)} ⊆ alph(s) , so that #B is, by definition, the degree of Wk .

264

M. Bucci and A. De Luca

We now consider the return words to w = Wk in s. Let u1 w = wv1 and u2 w = wv2 be any two distinct complete returns to w in s, and let us show that v1f = v2f . Indeed, let p be the longest common prefix of v1 and v2 . If p = v1 , then |v2 | > |v1 | as v1 = v2 ; since wv1 = u1 w, there is an internal occurrence of w in wv2 , contradicting the definition of complete return. The same argument applies if p = v2 . Thus p is a proper prefix of both v1 and v2 , so that wp is a right special factor of s. Since |w| ≥ N , and w is a right special factor of s, by condition 2 it follows that w is a suffix of wp. This implies p = ε, since otherwise there would be an internal occurrence of w in wv1 and wv2 . Hence v1f = v2f as desired. Since w is also left special in s, using a symmetric argument one can prove that u1 = u2 . From this it follows that for each x ∈ B, there exists a unique complete return ux w = wvx to w in s, such that vxf = x. We define a morphism ϕ : B ∗ → A∗ by ϕ(x) = ux . Note that ϕ is injective, as ϕ(B) is a suffix code having the same cardinality as B. By definition, we have s = ϕ(t), where t ∈ B ω is a derivated word of s with respect to its prefix w. We note that, as a consequence of the definition of return words, one has z ∈ Fact(t) ⇔ ϕ(z)w ∈ Fact(s) ,

z ∈ Pref(t) ⇔ ϕ(z)w ∈ Pref(s) .

(3)

We will prove that t is a standard Arnoux-Rauzy word; it suffices (see Remark 1) to show that t has exactly one right special factor of each length, that each right special factor has degree #B, and finally that all left special factors of t are prefixes of it. Clearly t is not periodic, as s = ϕ(t) and s is not periodic. Hence t has right special factors of any length. Let z1 and z2 be any two right special factors of t having the same length. Thus there exist distinct letters x1 , y1 , x2 , y2 ∈ B such that xi = yi and zi xi , zi yi ∈ Fact(t) for i = 1, 2. By (3), this implies ϕ(zi xi )w, ϕ(zi yi )w ∈ Fact(s). For α ∈ {xi , yi } and i = 1, 2 we have ϕ(zi α)w = ϕ(zi )uα w = ϕ(zi )wvα ∈ Fact(s) with vxf i = vyfi , so that ϕ(z1 )w and ϕ(z2 )w are right special factors of s. By condition 2, either ϕ(z1 )w ∈ Suff(ϕ(z2 )w), or vice versa. The word w has |z1 | + 1 = |z2 | + 1 occurrences in both ϕ(z1 )w and ϕ(z2 )w, and it is a prefix of both, by the definition of return word. Hence we derive ϕ(z1 )w = ϕ(z2 )w, so that z1 = z2 by the injectivity of ϕ. If z is a right special factor of t, by the above argument ζ := ϕ(z)w is right special in s. As |ζ| ≥ |w|, the word ζ is a suffix of some Wn with n ≥ k, so that ζx = ϕ(z)wx ∈ Fact(s) for all x ∈ B. Since the only complete return to w in s starting with wx is wvx , it follows that ϕ(z)wvx = ϕ(z)ux w = ϕ(zx)w ∈ Fact(s) , so that zx ∈ Fact(t) for all x ∈ B, proving that z has right degree #B. Let now z  be a left special factor of t, and let xz  , yz  ∈ Fact(t) for some distinct letters x, y ∈ B. Then ϕ(xz  )w, ϕ(yz  )w ∈ Fact(s). As ϕ(x) = ux =

On a Family of Morphic Images of Arnoux-Rauzy Words

265

uy = ϕ(y) , ϕ(z  )w is a left special factor of s. By condition 1, it follows ϕ(z  )w ∈ Pref(s) and then z  ∈ Pref(t) by (3).  

4

Concluding Remarks

Theorem 1 shows that what seems to be a natural (though very wide) generalization of the standard episturmian words, retains a strong connection with Arnoux-Rauzy words. One could ask whether such result could be improved to obtain a full characterization of morphic images of standard Arnoux-Rauzy words. However, the converse of Theorem 1 is false; a simple counterexample is given by the image s of the Tribonacci word under the episturmian morphism (cf. [5,8]) f : a → a, b → ba, c → ca. Indeed, s = f (τ ) = abaacaabaaabaacaabaabaacaabaaabaacaabaa · · · does not satisfy condition 1 of Theorem 1 for any N , as aa is a left special factor of s which is not a prefix of it. Nevertheless, this counterexample suggests that the situation could be better in the general (non-standard) case, since the word s, being episturmian, does have only one left special factor and one right special factor of each length. By modifying the proof of Theorem 1 suitably, it is not difficult to show the following: Theorem 3. If s ∈ Aω is recurrent and has at most one left special factor and one right special factor for all lengths k ≥ N , then there exist B ⊆ A, an injective morphism ϕ : B ∗ → A∗ , and an Arnoux-Rauzy word t ∈ B ω such that s ∈ Suff(ϕ(t)). This is somehow weaker than the original Theorem 1, as we only get that s is a suffix of a morphic image of an Arnoux-Rauzy word. Therefore, any improvement of Theorem 3 would be welcome, as well as any step towards the converse (what can be said about special factors of morphic images of ArnouxRauzy words?). Having a simple characterization could help in a more general classification of infinite words with low factor complexity.

References 1. Morse, M., Hedlund, G.A.: Symbolic dynamics. American Journal of Mathematics 60, 815–866 (1938) 2. Berstel, J., S´e´ebold, P.: Sturmian words. In: Lothaire, M. (ed.) Algebraic Combinatorics on Words. Cambridge University Press, Cambridge (2002) 3. Berstel, J.: Sturmian and episturmian words. In: Bozapalidis, S., Rahonis, G. (eds.) CAI 2007. LNCS, vol. 4728, pp. 23–47. Springer, Heidelberg (2007) 4. Arnoux, P., Rauzy, G.: Repr´esentation g´eom´etrique de suites de complexit´e 2n + 1. Bulletin de la Soci´et´e Math´ematique de France 119, 199–215 (1991)

266

M. Bucci and A. De Luca

5. Droubay, X., Justin, J., Pirillo, G.: Episturmian words and some constructions of de Luca and Rauzy. Theoretical Computer Science 255, 539–553 (2001) 6. Bucci, M., de Luca, A., De Luca, A., Zamboni, L.Q.: On different generalizations of episturmian words. Theoretical Computer Science 393, 23–36 (2008) 7. Lothaire, M.: Combinatorics on Words. Addison-Wesley, Reading (1983) 8. Justin, J., Pirillo, G.: Episturmian words and episturmian morphisms. Theoretical Computer Science 276, 281–313 (2002) 9. de Luca, A., De Luca, A.: Pseudopalindrome closure operators in free monoids. Theoretical Computer Science 362, 282–300 (2006) 10. Bucci, M., de Luca, A., De Luca, A., Zamboni, L.Q.: On θ-episturmian words. European Journal of Combinatorics 30, 473–479 (2009) 11. Fischler, S.: Palindromic prefixes and episturmian words. Journal of Combinatorial Theory, Series A 113, 1281–1304 (2006) 12. Durand, F.: A characterization of substitutive sequences using return words. Discrete Mathematics 179, 89–101 (1998) 13. de Luca, A., Varricchio, S.: Finiteness and regularity in semigroups and formal languages. Monographs in Theoretical Computer Science. An EATCS Series. Springer, Berlin (1999)

Monadic Datalog Tree Transducers Matthias B¨ uchse and Torsten St¨ uber, Faculty of Computer Science Technische Universit¨ at Dresden 01062 Dresden, Germany {buechse,stueber}@tcs.inf.tu-dresden.de

Abstract. We introduce a tree transducer model combining aspects of both attributed tree transducers and monadic datalog, thereby allowing to specify in one rule information transport for non-adjacent nodes. We show that our model is strictly more powerful than attributed tree transducers, and we identify a large syntactic subclass which is as powerful as attributed tree transducers. This is shown by an effective construction.

1

Introduction

In [1], (nondeterministic) attributed tree transducers, an abstract form of attribute grammars [2,3], are introduced as a formal model of syntax-directed semantics [4], that is, a model for specifying tree transformations. Monadic datalog [5], a syntactically restricted fragment of standard datalog [6], is a means of formally specifying node selection queries on trees. We roughly sketch the underlying ideas of both formalisms: First, a set of (property) names is defined, called attributes and predicates, respectively. For a given tree t, these names are instantiated for every node of t, yielding attribute instances and atom instances. A finite set of rules is then used to restrict the set of interpretations, that is, mappings from these instances to some semantic domain. In the case of attributed tree transducers, the semantic domain is the set of trees languages over an output alphabet, for monadic datalog, this is the set of Boolean values. If necessary, one interpretation is chosen according to criteria specific to the respective model, and the semantics associated with t is the value of some designated name instance. Rules of attributed tree transducers allow to specify the relationship of the values of attributes at nodes which are within the same fork, that is, some node together with its direct descendants. An example of a rule is Rσ :

a(π) → γ(a(π2)) .

The symbol π represents the position of the root of a fork. Here, the value of the attribute a at any node w is obtained by putting a γ atop the value of a  

Corresponding author. The work of this author was partially supported by Deutsche Forschungsgemeinschaft, project DFG VO 1011/4-1.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 267–278, 2009. c Springer-Verlag Berlin Heidelberg 2009 

268

M. B¨ uchse and T. St¨ uber

at the second descendant of w, given that w is labeled by σ. (Note that the arrow is pointing in the direction opposite of information transport because the rule is understood as a term-rewriting rule.) Obviously, every rule of an attributed tree transducer contains exactly one free variable, and this variable is only constrained by the label restriction. In contrast, rules of monadic datalog programs have an arbitrary number of free variables and constraints, thus specifying atom instance relationships much more freely. Consider the example rule p(x) ← q(x1 ), child1 (x, x1 ), child2 (x, x2 ), labelσ (x2 ), labelα (z) . The comma is interpreted as conjunction. When instantiating the variables with nodes of t, we see that the value of the predicate p at any node w is determined by the value of the predicate q at the first descendant of w, given that the second descendant is labeled by σ and there is a node in t labeled by α. In this paper, we introduce monadic datalog tree transducers, combining aspects of both approaches (under monadic datalog nomenclature)—the semantic domain of attributed tree transducers and the liberal style rules of monadic datalog. Attributed tree transducers can be described in our model without difficulty; the example rule mentioned above can be transferred as follows: a(x) ← γ(a(y)) ; {child2 (x, y), labelσ (x)} . As opposed to monadic datalog, structural predicates—which are used to place constraints on the variables—and user-defined predicates have to be handled separately because the former are interpreted over the set of Booleans and the latter are interpreted over sets of output trees. In the literature, different technical tools are known to define semantics for the formalisms we deal with here. Term rewriting [7] is usually used for attributed tree transducers [4]. In this approach, semantics can be evaluated in finite time exactly for a decidable subclass called noncircular. On the other hand, least fixpoint semantics is used for both attribute grammars [8] and monadic datalog. We define semantics for monadic datalog tree transducers in the latter way. We give a coarse intuition. By computing all rule instances which are valid wrt an input tree t, we obtain a system of inequalities. The semantics associated with t is then obtained from the least interpretation satisfying the inequalities, where interpretations are ordered by the usual extension of the subset relation. Technically, the semantics is defined as the least fixpoint of an immediate consequence operator over the set of interpretations. In Theorem 1, we will see that the semantics of a monadic datalog tree transducer can be evaluated in finite time iff the set of output trees is finite for every input tree. As a consequence, every semantics-preserving transformation on monadic datalog tree transducers automatically preserves computability. However, we do not know whether it is decidable for every monadic datalog tree transducer if its semantics can be evaluated in finite time. Moreover, we will see in Theorem 2 that the class of tree transformations induced by monadic datalog tree transducers is a proper superclass of those

Monadic Datalog Tree Transducers

269

induced by attributed tree transducers. We establish a syntactic property called restricted which guarantees that the semantics can be computed by some attributed tree transducer (Theorem 3); this is shown by giving an effective construction. While restrictedness is not a necessary condition, we conjecture that it is the most general sufficient condition which only relies on the syntax of individual rules.

2

Preliminaries

We use IN to denote the set of non-negative integers and IN+ to denote IN \ {0}. For n ∈ IN we abbreviate {i ∈ IN+ | i ≤ n} by [n]. We denote the power set of a set A by P(A) and the set of finite subsets of A by Pfin (A). Alphabets and ranked alphabets are defined as usual. We denote the set of strings over an alphabet Δ by Δ∗ . We use Σ (k) to denote the set of k-ary symbols of a ranked alphabet Σ and write σ (k) for σ ∈ Σ to indicate that the rank of σ is k. We call Σ monadic iff Σ = Σ (0) ∪ Σ (1) . Let H be a set. The set TΣ (H) of Σ-trees indexed by H is defined as usual. We abbreviate TΣ (∅) by TΣ . Moreover, we define Σ(H) = {σ(h1 , . . . , hk ) | k ∈ IN, σ ∈ Σ (k) , h1 , . . . , hk ∈ H} ⊆ TΣ (H). Let t ∈ TΣ . By pos(t) ⊆ IN∗ we denote the set of positions of t and by ind(t) ⊆ H the set of indices occurring in t; e.g. t = δ(σ(h1 ), α, h2 ) and H = {h1 , h2 , h3 } yield pos(t) = {ε, 1, 11, 2, 3} and ind(t) = {h1 , h2 }. For w, w ∈ pos(t) we write w ≤ w iff w is a prefix of w . For every w ∈ pos(t) and t ∈ TΣ we write t(w), rkt (w), t|w , and t[t ]w for the symbol that occurs at position w in t, the rank of t(w), the subtree of t rooted at w, and the tree obtained from t by replacing the subtree rooted at w by t , respectively. The height height(t) of t is defined as usual, where height(σ) = 0 for every σ ∈ Σ (0) .

3

Monadic Datalog Tree Transducers

In this section we define the syntactic structure of monadic datalog tree transducers. Throughout this work, we fix an infinite set V , the elements of which being called variables. Moreover, we fix two ranked alphabets Σ and Δ (of input symbols and output symbols, respectively). Let maxrk(Σ) denote the maximal rank of symbols in Σ. We define a ranked alphabet spΣ by letting (2)

spΣ = {root(1) , leaf (1) } ∪ {label(1) σ | σ ∈ Σ} ∪ {childi

| i ∈ [maxrk(Σ)]} .

We refer to the elements of spΣ as structural predicates over Σ. Definition 1. A triple (P, R, q) is called a monadic datalog tree transducer (for short: mdtt) over Σ and Δ iff – P is a monadic ranked alphabet (of user-defined predicates), – R ⊆ P (V ) × TΔ (P (V )) × Pfin (spΣ (V )) is a finite set (of rules), – q ∈ P (1) (called query predicate).

270

M. B¨ uchse and T. St¨ uber

A rule r = (h, b, G) ∈ R is denoted by h ← b ; G and h, b, and G are called head, body, and guard of r, and are denoted by rh , rb , and rG , respectively. We refer to the elements in P (V ) ∪ spΣ (V ) as atoms. Now we define the semantics of mdtts. As a technical tool we will use common order theoretic concepts. An introduction into order theory can be found, e.g., in [9]. In the sequel let M = (P, R, q) be an mdtt over Σ and Δ. Let t ∈ TΣ . We refer to the elements in P (pos(t)) ∪ spΣ (pos(t)) as atom instances (over t). The tree t constitutes a set Bt ⊆ spΣ (pos(t)) of atom instances compatible with t defined as: Bt = {root(ε)} ∪ {leaf(w) | w ∈ pos(t), rkt (w) = 0} ∪ {childi (w, wi) | w ∈ pos(t), i ∈ [rkt (w)]} ∪ {labelσ (w) | w ∈ pos(t), t(w) = σ} . Let r ∈ R. We put var(r) = var(rh ) ∪ var(rb ) ∪ var(rG ), where var(rh ) denotes the set of variables that occur in rh , and likewise for rb and rG . An r, tvariable assignment is a mapping ρ : var(r) → pos(t). We lift ρ to TΔ (P (var(r))) and P(spΣ (var(r))) in an obvious manner; e.g. ρ(v1 ) = 1 and ρ(v2 ) = ε yield ρ(δ(p(v1 ), q(v2 ))) = δ(p(1), q(ε)). We call ρ valid iff ρ(rG ) ⊆ Bt . For every a ∈ P (pos(t)) we denote by Φr,t,a the set of valid r, t-variable assignments ρ such that ρ(rh ) = a. An interpretation over M and t is a mapping I : P (pos(t)) → P(TΔ ). We denote the set of all interpretations over M and t by IM,t . We define a partial order ≤ on IM,t as follows for every I1 , I2 ∈ IM,t : I1 ≤ I2 iff I1 (a) ⊆ I2 (a) for every a ∈ P (pos(t)). The resulting poset (IM,t , ≤) is ω-complete. Let I ∈ IM,t . We extend I to TΔ (P (pos(t))) in the following sense: the I-instance b[I] ∈ P(TΔ ) for b ∈ TΔ (P (pos(t))) is defined for every δ(b1 , . . . , bk ) ∈ TΔ (P (pos(t))) by δ(b1 , . . . , bk )[I] = {δ(t1 , . . . , tk ) | t1 ∈ b1 [I], . . . , tk ∈ bk [I]} . We define the immediate consequence operator TM,t : IM,t → IM,t over M and t by letting for every I ∈ IM,t and a ∈ P (pos(t)):   TM,t (I)(a) = r∈R ρ∈Φr,t,a ρ(rb )[I] . n to denote the n-fold composition of TM,t for n ∈ IN. Obviously, TM,t We use TM,t n+1 n is ω-continuous and, thus, monotone wrt ≤. Hence, TM,t (I∅ ) ≤ TM,t (I∅ ) for every n ∈ IN, where I∅ denotes the minimal element of IM,t . Therefore, the fixpoint theorem of Knaster-Tarski [9, Theorem 1.5.7] yields that the least fixpoint of the n ω (I∅ ) | n ∈ IN}, which we denote by TM,t . mapping TM,t is sup{TM,t

Definition 2. The tree transformation [[M ]] : TΣ → P(TΔ ) computed by M is ω defined for every t ∈ TΣ by [[M ]](t) = TM,t (q(ε)). The set of tree transformations computed by mdtts over Σ and Δ is denoted by MDTT(Σ, Δ). Now we consider a simple example mdtt Mex = (P, R, q) over Σ = {α(0) , γ (1) } and Δ = Σ ∪ {δ (4) }, where P = {q (1) , r(1) } and R contains the rules

Monadic Datalog Tree Transducers

271

q(x) ← δ(r(y), r(z), r(y), r(z)) ; ∅ r(x) ← α ; {labelα (x)} r(x) ← γ(x1 ) ; {labelγ (x), child1 (x, x1 )} Then [[Mex ]](t) = {δ(t|w , t|v , t|w , t|v ) | w, v ∈ pos(t)} for every t ∈ TΣ . n (I∅ )(q(ε)) = [[M ]](t), then [[M ]](t) is obviously If there is an n ∈ IN with TM,t finite. It is easy to see that the converse holds as well because TM,t is monotone wrt ≤. We show that in order to determine whether [[M ]](t) is finite it suffices to consider n = |P (pos(t))|. n Theorem 1. Let t ∈ TΣ . Then [[M ]](t) is finite iff [[M ]](t) = TM,t (I∅ )(q(ε)), where n = |P (pos(t))|.

Corollary 1. Let hm = max{height(rb ) | r ∈ R}. Then for every t ∈ TΣ either the height of trees in [[M ]](t) is unbounded or bounded by hm · |P (pos(t))|. We call M executable iff [[M ]](t) is finite for every t ∈ TΣ . Let M  = (P  , R , q  ) be an mdtt over Σ and Δ. We call M and M  equivalent iff [[M ]] = [[M  ]]. The following lemma provides a method for proving that M and M  are equivalent. Lemma 1. If for every t ∈ TΣ there is a fixpoint I of TM,t and a fixpoint I  of TM  ,t such that I(q(ε)) = [[M  ]](t) and I  (q  (ε)) = [[M ]](t), then [[M ]] = [[M  ]].

4

Comparison to Attributed Tree Transducers

We define attributed tree transducers according to [10, Sect. 2.3]. For the remainder of this paper, let M = (P, R, q) be an mdtt over Σ and Δ. As a prerequisite, we fix an injective mapping x : IN∗ → V ; we denote x(IN∗ ) by X, x(w) by xw , and {x1 , . . . , xk } by Xk for every w ∈ IN∗ and k ∈ IN. Definition 3. The mdtt M is an attributed tree transducer (for short: att) over Σ and Δ iff there are disjoint sets Asyn and Ainh such that P = P (1) = Asyn ∪ Ainh , q ∈ Asyn , and the following holds for every r ∈ R: – either there are k ∈ IN, σ ∈ Σ (k) , a ∈ Asyn ({xε }) ∪ Ainh (Xk ) and b ∈ TΔ (Asyn (Xk ) ∪ Ainh ({xε })) such that r = a ← b ; {labelσ (xε ), child1 (xε , x1 ), . . . , childk (xε , xk )} – or there are a ∈ Ainh ({xε }) and b ∈ TΔ (Asyn ({xε })) such that r = a ← b ; {root(xε )} . The class of all tree transformations computed by attributed tree transducers over Σ and Δ is denoted by ATT(Σ, Δ). The class ATT(Σ, Δ) defined here can be best compared with the class T A from [1], which differs from ATT(Σ, Δ) in that it only takes noncircular atts

272

M. B¨ uchse and T. St¨ uber

into account, a decidable syntactic subclass which guarantees that the semantics can be evaluated in finite time in their framework. If M is an att, then for every rule r ∈ R and every pair of variables x, y ∈ var(r), x and y are directly or indirectly connected by the child relation. In contrast, the mdtt Mex does not have this property. We define a syntactic property based on variable connections which is satisfied by every att and show that it imposes a restriction on semantics. Definition 4. Let r ∈ R. We define the variable connection relation ∼r of r as the reflexive-transitive closure of {(v1 , v2 ) ∈ var(r)×var(r) | ∃ a ∈ rG : {v1 , v2 } ⊆ var(a)}. We call r restricted iff for every w1 , w2 ∈ pos(rb ), we have: if ∅ =   var(rb |w1 ) × var(rb |w2 ) ⊆ ∼r , then var(rb |w ) × var(rb |w ) ⊆ ∼r , where w is the longest common prefix of w1 and w2 . Moreover, we call M restricted if every r ∈ R is restricted. The class of all tree transformations computed by restricted mdtts over Σ and Δ is denoted by RMDTT(Σ, Δ). Theorem 2. There are Σ and Δ such that MDTT(Σ, Δ) ⊆ RMDTT(Σ, Δ). Theorem 3. RMDTT(Σ, Δ) = ATT(Σ, Δ). In the rest of this section, we prove this theorem by introducing three syntactic properties for mdtts such that we obtain a sequence P1 ⊃ . . . ⊃ P5 of syntactic classes where P1 and P5 are restricted and att, respectively, and for every i ∈ [4] and M ∈ Pi there is effectively an equivalent M  ∈ Pi+1 . Hence, att is a normal form for restricted mdtts. We note that restrictedness is no necessary condition for an mdtt to have a semantics in ATT(Σ, Δ). However, we conjecture that it is the most general sufficient condition which only relies on the syntax of individual rules. 4.1

Connected

The first syntactic property is inspired by [5, Theorem 4.2]. A rule r ∈ R is called connected iff ∼r = var(r) × var(r). We call M connected iff every r ∈ R is connected. In the following, we motivate informally the constructions involved in giving a connected mdtt equivalent to M . To this end, consider the rule r = p(x) ← δ(q(x), p(y)) ; {labelγ (z)} . Let t ∈ TΣ . We can make two observations: First, the variable z is not connected (i.e., related by ∼r ) to any variable occurring in rh or rb . Thus, if t contains a node labeled γ, we can omit the guard, and otherwise, we can omit the whole rule, each time preserving semantics for t. This idea can be used for a construction which does not depend on t, but suffice it to say that this involves duplication of all the remaining rules. Therefore, in order to have a terminating procedure, our construction deals with all rules at once. Second, the variable y, while trivially connected to some variable in the body, is not connected to the variable in

Monadic Datalog Tree Transducers

273

the head. In this case, we may replace p(y) by p (), where p is a new nullary predicate, adding a rule p () ← p(y) ; ∅. We define for every r ∈ R the set of independent guards I(r) = {a ∈ rG |    ∀v ∈ var(a)  : ∀v ∈ var(rh ) ∪ var(rb ) : v ∼r v } and for every R ⊆ R the set  I(R ) = r∈R I(r). We call M semiconnected iff r is connected or I(r) = ∅ for every r ∈ R. Lemma 2. There is a semiconnected mdtt M  equivalent to M such that M  is restricted if so is M . Proof. Without loss of generality, we assume that var(r1 ) ∩ var(r2 ) = ∅ implies r1 = r2 for every r1 , r2 ∈ R. For every G ⊆ spΣ (V ) we define the language accepted by G by L(G) = {t ∈ TΣ | ∃ρ : var(G) → pos(t) : ρ(G) ⊆ Bt }. Observe that var(G1 ) ∩ var(G2 ) = ∅ implies L(G1 ∪ G2 ) = L(G1 ) ∩ L(G2 ) for every G1 , G2 ⊆ spΣ (V ).  Let R ⊆ R. We construct the semiconnected mdtt τ1R (M ) = (P, R1 , q) where R1 = {rh ← rb ; rG \ I(r) | r ∈ R }. Note that the construction preserves  restrictedness. If t ∈ L(I(R )), then [[τ1R (M )]](t) ⊆ [[M ]](t). Thisholds because t satisfies all the guards which were omitted. If t ∈ L(I(R )) \ r∈R\R L(I(r)), then we even have equality for then we have indeed only removed rules which have no valid assignments. Let G ⊆ spΣ (V ) be finite. We construct an mdtt τ2G (M ) such that the following holds: [[τ2G (M )]](t) = [[M ]](t) if t ∈ L(G), and [[τ2G (M )]](t) = ∅ otherwise. I(R ) R Thus, [[τ2 (τ1 (M ))]](t) ⊆ [[M ]](t) for every t ∈ TΣ . We define ∼G as the reflexive-transitive closure of {(a1 , a2 ) ∈ G × G | var(a1 ) ∩ var(a2 ) = ∅}. Let {G1 , . . . , Gk } = G/∼G . We construct τ2G (M ) = (P ∪ P  , R ∪ R , p0 ) where (1) (0) (0)  P = {p0 } ∪ {p1 , . . . , pk } is disjoint from P and (setting pk+1 = q) R = {p0 (x) ← p1 () ; ∅} ∪ {pi () ← pi+1 () ; Gi | i ∈ [k]}. Note that this construction preserves semiconnectedness and restrictedness. Finally, let J be a finite set and (Mi | i ∈ J) a family of mdtts over Σ and Δ such that  Mi = (Pi , Ri , qi ) for every i ∈ J. The unionmdtt of (Mi | i ∈ J) is defined by i∈J Mi = (P  , R , q  ) where P  = {q  } ∪ i∈J Pi × {i} and R = {q  (x) ← (qi , i)(x) ; ∅ | i ∈ J} ∪ i∈J Ri where Ri is obtained from Ri  by replacing every occurrence of every p ∈ P by (p, i). Clearly, [[ M i i ]](t) = i∈J   [[M ]](t) for every t ∈ T , and M is semiconnected (restricted) iff for i Σ i i∈J i∈J every i ∈ J, so is Mi .  I(R ) R Now we are able to construct M  = R ⊆R τ2 (τ1 (M )). Clearly, M  is semiconnected, and M  is restricted if so is M . We show that [[M  ]] = [[M ]].  Let t ∈ TΣ and  R = {r ∈ R | t ∈ L(I(r))}. Then it is easy to see that t ∈ L(I(R )) \ r∈R\R L(I(r)). Hence, [[M  ]](t) = [[M ]](t).   Lemma 3. Let M be restricted and semiconnected. Then there is a connected mdtt M  equivalent to M . Proof. Let r ∈ R, C ∈ var(r)/∼r an equivalence class disjoint from var(rh ), and G = {a ∈ rG | var(a) ⊆ C}. Since M is semiconnected, C ∩ var(rb ) = ∅. Since M is restricted, there is a position w ∈ pos(rb ) such that for every w ∈

274

M. B¨ uchse and T. St¨ uber

pos(rb ) with rb (w) ∈ P (V ), we have w ≤ w iff rb (w ) ∈ P (C). Our construction replaces the subtree rb |w by an atom p() (where p is a new predicate), removes from the guard of r the atoms in G, and adds a rule p() ← rb |w ; G. Clearly, this construction preserves semantics, semiconnectedness, and restrictedness. It is easy to see that applying it finitely often yields the desired result.   We make an observation concerning connected mdtts which makes it possible to simplify further considerations significantly. Consider the rule r = p(x) ← δ(q(x), p(y)) ; {child1 (z, x), child2 (z, y)} . For every t ∈ TΣ and valid r, t-variable assignment ρ, we obtain ρ(x) = ρ(z)1 and ρ(y) = ρ(z)2. Hence, we may reflect this fact in syntax by rephrasing r to p(x1 ) ← δ(q(x1 ), p(x2 )) ; {child1 (xε , x1 ), child2 (xε , x2 )} . Now we generalize this. The mdtt M is called positional iff M is connected and for every r ∈ R, we have that var(r) ⊆ X, xε ∈ var(r), and for every w, w ∈ IN∗ and i ∈ IN+ , if childi (xw , xw ) ∈ rG , then w = wi. Lemma 4. Let M be connected. There is a positional mdtt M  equivalent to M . Proof. Let r ∈ R. A mapping τ : var(r) → IN∗ is called r-position mapping iff for every v, v  ∈ var(r) and i ∈ IN+ , if childi (v, v  ) ∈ rG , then τ (v)i = τ (v  ). It can be shown that, if var(r) = ∅, there is at most one r-position mapping τ such that τ (v) = ε for some v ∈ var(r), which we denote by τr . If var(r) = ∅, we define τr to be the empty mapping. If τr does not exist, then Φr,t,a is empty for every t and a. It is decidable whether τr exists, and if it does, it can be computed. We construct M  = (P, R , q) where R = {τr (r) | ∃r ∈ R : τr exists} and τr (r) is obtained from r by replacing every occurrence of every v ∈ var(r) by xτr (v) .   4.2

Proper

The mdtt M is called proper iff all predicates in P are unary, i.e. P (0) = ∅. In this section we show how to construct an equivalent mdtt M  that is proper. This construction maintains the positional property. Lemma 5. There is a proper mdtt M  equivalent to M such that M  is positional if so is M . Proof. The idea of our construction is to replace every p ∈ P (0) by a unary variant p¯ of p. More precisely, we have to replace every occurrence of the atom p() by the atom p¯(xε ); this guarantees that M  is positional if M is positional. Additionally we add rules that ensure that the value of the atom instance p¯(w) is equal for every position w ∈ pos(t). p(1) | p ∈ P (0) } and We define M  = (P  , R , q) as follows: P  = P (1) ∪ {¯ up down  (0) R = {¯ r | r ∈ R} ∪ {rp,i , rp,i | p ∈ P , i ∈ [maxrk(Σ)]}, where r¯ is obtained

Monadic Datalog Tree Transducers

275

from r by replacing for every p ∈ P (0) every occurrence of p() by p¯(xε ), and for every p ∈ P (0) and i ∈ [maxrk(Σ)] we let up = p¯(xε ) ← p¯(xi ) ; childi (xε , xi ) , rp,i down = p¯(xi ) ← p¯(xε ) ; childi (xε , xi ) . rp,i ω ω p(w)) = TM,t (p()) for every w ∈ pos(t). Then Let p ∈ P (0) . Then we have TM  ,t (¯  it is easy to see that M is equivalent to M . Moreover, M  is obviously proper and it is positional if M is so.  

4.3

Local

If M is positional, then the set var(r) can be an arbitrary finite subset of X for every r ∈ R. However, for atts, var(r) must be a subset of Xε , where Xε = {xε }∪{xi | i ∈ IN+ }. Therefore, the rules of an att take effect only on a local part of the input tree. Formalizing this, we define an order ≤ on X by letting xw ≤ xw iff w is a prefix of w for every w, w ∈ IN∗ . We let var1 (a) = min(var(a)) for every a ∈ spΣ (X), and call an r ∈ R local iff var1 (a) = xε for every a ∈ rG . The mdtt M is called local iff it is proper, positional, and every rule in R is local. In this section we show that for every proper and positional mdtt there is an equivalent local one. First we give a brief explanation of our construction. Let r be the rule q(xε ) ← p(x21 ) ; {child2 (xε , x2 ), child1 (x2 , x21 ), labelσ (x2 )}. In order to make r local we split it into local components while introducing an auxiliary predicate p ; hence, we obtain two rules q(xε ) ← p (x2 ) ; {child2 (xε , x2 )} , p (xε ) ← p(x1 ) ; {child1 (xε , x1 ), labelσ (xε )} . Special care has to be taken if both the head and the body of the given rule belong entirely to one of the local components: consider the rule r which originates from r by replacing the variable x21 in the body by xε . In this case we have to make a detour and construct three rules q(xε ) ← p (x2 ) ; {child2 (xε , x2 )} , p (xε ) ← p (xε ) ; {child1 (xε , x1 ), labelσ (xε )} , p (x2 ) ← p(xε ) ; {child2 (xε , x2 )} . Lemma 6. Let M be positional and proper. Then there is a local mdtt Mloc equivalent to M . Proof. We do not construct the mdtt Mloc at once. Rather we give a construction of a positional and proper mdtt M1 and argue that a finite number of applications of this construction leads to Mloc . Assume that M is not yet local. Select a rule r ∈ R that is not local and select a maximal x in the set {var1 (a) | a ∈ rG }. Then x = xε .

276

M. B¨ uchse and T. St¨ uber

We let A = {a ∈ {rh } ∪ ind(rb ) | ∃ v ∈ var(a) : v > x} and G = {a ∈ rG | var1 (a) = x}. We define an intermediate mdtt M0 = (P0 , R0 , q) by case distinction. Case 1: A = ∅. Then P0 = P ∪ {p1 , p2 } and R0 = (R \ {r}) ∪ {r1 , r2 , r3 }: r1 = rh ← p1 (x) ; rG \ G , r2 = p1 (x) ← p2 (x) ; G , r3 = p2 (x) ← rb ; rG \ G . a | a ∈ A} where a ¯ is a new predicate for Case 2: A = ∅. Then P0 = P ∪ {¯ every a ∈ A, and R0 = (R \ {r}) ∪ {¯ r } ∪ R , where r¯ is obtained from r by replacing every occurence of every a ∈ A by a ¯(x) and replacing rG by rG \ G, and R is the smallest set such that for every a ∈ A: – if a = rh , then R contains the rule a ← a ¯(x) ; G ¯(x) ← a ; G – if a ∈ ind(rb ), then R contains the rule a The mdtt M1 is obtained from M0 by making it positional. Obviously, every rule r that is added in this construction is either local or  satisfies rG ⊂ rG . Since a multiset order is terminating whenever it is defined based on a terminating strict order (see Theorem 2.5.5 in [7]) we obtain that a finite number of applications of this construction leads to a local mdtt Mloc . 4.4

Attributed Tree Transducers

In this section we show that we can transform every local mdtt M into an equivalent attributed tree transducer. Lemma 7. Let M be local. There is an att M  equivalent to M . Proof (Sketch). First let us list the syntactic differences between local mdtts and atts: 1. for atts certain atoms are mandatory in guards, e.g. labelσ (xε ) or root(xε ), and certain atoms are not allowed to occur, e.g. leaf(xε ), 2. the set of user-defined predicates is partitioned into inherited and synthesized attributes, 3. rules whose guard contains root(xε ) have to be of a very restricted form. Our construction of M  is divided into three phases, each of which dealing with one of the syntactic differences in the order listed above. Phase 1. This construction is split into five steps. In the first step we drop all rules r such that there are distinct σ, σ  ∈ Σ with {labelσ (xε ), labelσ (xε )} ⊆ rG , since these rules are obviously inconsistent. In the second step we take care of all rules whose guard does not yet contain labelσ (xε ) for any σ ∈ Σ. For such a rule r we add for every σ ∈ Σ a copy of r that additonally contains labelσ (xε )

Monadic Datalog Tree Transducers

γ

p

q

(p, inh)

γ

(p, syn)

q

γ

p

q

(p, inh)

γ

(p, syn)

q

α

p

q

(p, inh)

α

(p, syn)

q

277

Fig. 1. Illustration of the construction of Phase 2

in the guard. Afterwards we remove r. In the resulting mdtt we have that  ; we denote for every rule r there is a unique σ ∈ Σ with labelσ (xε ) ∈ rG this σ by σr . In the third step we add to the guard of every rule r the atoms child1 (xε , x1 ), . . . , childk (xε , xk ) where k = rk(σr ). In the fourth step we remove all rules that are obviously inconsistent; these are all rules r such that (i) rk(σr ) > 0 and leaf(xε ) ∈ rG or (ii) childi (xε , xi ) ∈ rG for some i > rk(σr ). In the fifth step we consider all rules r whose guard contains leaf(xε ): by the construction in the fourth step it is obvious that rk(σr ) = 0. Therefore leaf(xε ) is redundant in rG and we can simply drop it. The constructions that are carried out in each step yield an mdtt equivalent to the original one. Note that we deal with all rules that contain root(xε ) in Phase 3. Phase 2. Suppose that M has already passed Phase 1. We give an intuitive description of our construction. Assume that P = {p, q} and consider the input tree γ(γ(α)). Furthermore assume that R determines data transport from p(ε) to p(1), p(11) to p(1), p(1) to q(ε), and p(1) to q(11). This situation is depicted on the left-hand side of Fig. 1, where the data transport is represented by dashed arrows. Obviously, p behaves both like a synthesized and an inherited attribute. Thus, we have to replace p by a predicate (p, syn) (simulating its synthesizing behavior, i.e., transporting data bottom-up) and a predicate (p, inh) (simulating its inheriting behavior, i.e., transporting data top-down). Since (p, syn) should also receive all the data that p receives from the top part of the tree, we need to introduce a rule which transports data from (p, inh) to (p, syn). The same holds for (p, inh): here we need to add a rule for transporting data from (p, syn) to (p, inh) (note that we need to take special care for the root of the tree). This is illustrated on the right-hand side of Fig. 1. Phase 3. Suppose that M has already passed Phases 1 and 2. If M is not already an att, then there is a rule r containing root(xε ). We remove this rule from M , add two new user-defined predicates (r, syn) and (r, inh), and add the rules rh ← (r, inh)(xε ) ; rG \ {root(xε )} , (r, inh)(xε ) ← (r, syn)(xε ) ; {root(xε )} , (r, syn)(xε ) ← rb ; rG \ {root(xε )} .

278

M. B¨ uchse and T. St¨ uber

Obviously, these three new rules comply with the definition of atts. Thus, by doing this construction for every non-compliant rule we will eventually obtain an att equivalent to M .   4.5

Open Problems

We did not yet address the following problems. (1) Is the subclass of executable mdtts decidable? (2) Do executable atts have the same computational power as noncircular atts [4]? (3) Characterizing the class MDTT(Σ, Δ)\RMDTT(Σ, Δ). Acknowledgements. The authors are grateful to Heiko Vogler for helpful discussions and valuable suggestions.

References 1. F¨ ul¨ op, Z.: On attributed tree transducers. Acta Cybernet 5, 261–279 (1981) 2. Knuth, D.: Semantics of context–free languages. Math. Systems Theory 2, 127–145 (1968) 3. Deransart, P., Jourdan, M., Lorho, B.: Attribute Grammars - Definitions, Systems and Bibliography. In: Deransart, P., Lorho, B., Jourdan, M. (eds.) Attribute Grammars. LNCS, vol. 323. Springer, Heidelberg (1988) 4. F¨ ul¨ op, Z., Vogler, H.: Syntax-directed semantics — Formal Models Based on Tree Transducers. Monogr. Theoret. Comput. Sci. EATCS Ser. Springer, Heidelberg (1998) 5. Gottlob, G., Koch, C.: Monadic datalog and the expressive power of languages for web information extraction. J. ACM 51(1), 74–113 (2004) 6. Abiteboul, S., Hull, R., Vianu, V.: Foundations of Databases. Addison-Wesley, Reading (1995) 7. Baader, F., Nipkow, T.: Term Rewriting and All That. Cambridge University Press, Cambridge (1998) 8. Chirica, L.M., Martin, D.F.: An Order-Algebraic Definition of Knuthian Semantics. Math. Systems Theory 13, 1–27 (1979) 9. Wechler, W.: Universal Algebra for Computer Scientists, 1st edn. Monogr. Theoret. Comput. Sci. EATCS Ser., vol. 25. Springer, Heidelberg (1992) 10. Bloem, R., Engelfriet, J.: A comparison of tree transductions defined by monadic second order logic and by attribute grammars. J. Comput. System Sci. 61, 1–50 (2000)

On Extended Regular Expressions Benjamin Carle and Paliath Narendran Dept. of Computer Science University at Albany–SUNY Albany, NY 12222

Abstract. In this paper we extend the work of Campeanu, Salomaa and Yu [1] on extended regular expressions featured in the Unix utility egrep and the popular scripting language Perl. We settle the open issue of closure under intersection and provide an improved pumping lemma that will show that a larger class of languages is not recognizable by extended regular expressions. We also investigate some questions regarding extended multi-pattern languages introduced by Nagy in [2].

1

Introduction

Grep, a well-known command line search utility, is used regularly on Unix and other operating systems to find matching lines in files or standard input. Grep uses regular expressions to match patterns, thereby allowing a user to quickly find important data in very large files or command output. Egrep, a variant of grep, uses extended regular expressions1 to increase the set of languages recognizable by the utility. Because the set of languages recognized by egrep is larger than that of theoretical regular expressions, it is important to understand the expressive power of this utility. In this paper we extend the pioneering work of [1]; we show that the family of languages recognizable by extended regular expressions is not closed under intersection, thereby settling an open problem. Furthermore, we introduce a different pumping lemma and use that lemma to show a class of languages that satisfy the pumping property of [1] but are not expressible by extended regular expressions. We also investigate some decidability and complexity issues. We also consider the work of Nagy [2] which extends the multi-pattern languages (MPL) defined by Kari, Mateescu, Paun and Salomaa [3]. We show that the class Nagy defines, which we call extended multi-pattern languages (EMPL), is a strict subclass of the family of languages recognized by egrep. We also settle some questions that are left open in [2].

2

Definitions

The syntax of extended regular expressions as in egrep and Perl is defined in [1]. Standard regular expressions, as specified in formal language theory, are 1

Note our definition of extended regular expressions includes backreferences unlike the definition given in some other sources.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 279–289, 2009. c Springer-Verlag Berlin Heidelberg 2009 

280

B. Carle and P. Narendran

extended using backreferences. The backreference \n stands for the string previously matched by the regular expression between the nth left parenthesis and the corresponding right parenthesis. As is well-known, this significantly increases expressive power; for instance, the expression ((aa)+a)\1* specifies the language { ai | i > 0 and i is not a power of 2} which is not even context-free. Similarly (a+)(b+)\1\2 specifies { ai bj ai bj | i, j > 0} which is not context-free either. For clarity, let us number left parentheses, starting with 1, from the left. Give the same numbers to the corresponding (matching) right parentheses. (...(...)...(...)...) 1

2

2

3

3

1

As in [1] we assume that any occurrence of a backreference \m in an extended regular expression is preceded by ) . m

Matching a string with an extended regular expression (eregex-matching) is often defined as follows (paraphrasing [4]): 1. If a is a symbol in the alphabet, then a matches a. 2. if r matches a string x, then ( r ) matches x and the value x is assigned to i

3. 4. 5. 6.

i

\i. \j matches the string that has been assigned to it. if r1 and r2 are eregexes, then r1 ∪ r2 matches any string matched by either r1 or r2 . if r1 and r2 are eregexes, then r1 r2 matches any string of the form xy where r1 matches x and r2 matches y. if r is an eregex, then r∗ matches any string of the form x1 . . . xn , n ≥ 0, where r matches each xi (1 ≤ i ≤ n).

A more precise definition of a match is given in [1] using ordered trees. We give below that definition too, with a slight modification. Positions in an ordered tree are denoted by sequences of positive integers, with the empty sequence denoting the root position. (See [5] for a formal definition.) Note that left-to-right lexicographic order ≺lex among positions corresponds to pre-order traversal. An ordered tree T is a valid match-tree for w and α if and only if: 1. The root of T has the label (w, α). 2. For every node u ∈ dom(T ), (a) if T (u) = (w, a) for some a ∈ Σ, then u is a leaf node and w = a. (b) if T (u) = (w, β1 β2 ), then u has two children labeled, respectively, by (w1 , β1 ) and (w2 , β2 ) where w1 w2 = w. (c) if T (u) = (w, β1 |β2 ), then u has one child labeled by either (w, β1 ) or (w, β2 ).

On Extended Regular Expressions

281

(d) if T (u) = (w, β ∗ ), then either u is a leaf node and w = λ or u has k ≥ 1 children labeled by (w1 , β), . . . , (wk , β) where each wi ∈ Σ + , and w = w1 . . . wk . (e) if T (u) = (w, ( γ )), then it has one child labeled by (w, γ). i

i

(f) if T (u) = (w, \m), then u is a leaf node, ( β ) is a subexpression of α, m

m

and there is a node v to the left of u such that T (v) = (w, ( β ) ) and m

m

no node between v and u has ( β ) in its label. In other words, w is the m

m

string previously (in the left-to-right pre-order) matched by ( β ) . m

m

The difference between this definition and the one in [1] is that unassigned backreferences are not set to the empty string λ as default in our definition. Thus there is no valid match-tree for b and ((aa)|\2b). The language denoted by an extended regular expression α is defined as L(α) = { w ∈ Σ ∗ | (w, α) is the label at the root of a valid match-tree }. Let EREG be the family of languages defined by extended regular expressions. A language L is an EREG language if and only if there is an extended regular expression α such that L = L(α). In relation to the regular languages (REG), it can be seen that REG ⊂ EREG.

3

The Results on EREG Languages

Campeanu, Salomaa and Yu [1] proved the following pumping lemma for EREG languages. To the best of our knowledge, this is the only pumping lemma of its kind. Lemma 1. (The CSY Pumping Lemma) [1] Let α be an extended regular expression. Then there is a constant N > 0 such that if w ∈ L(α) and |w| > N , then there is a decomposition w = x0 yx1 y · · · yxm , for some m ≥ 1, such that 1. |x0 y| < N , 2. |y| ≥ 1, and 3. x0 y j x1 y j · · · y j xm ∈ L(α) for all j > 0. Lemma 2. The language S = { ai bai+1 bak | k = i(i + 1)k  for some k  > 0, i > 0 } is not an EREG language. Proof: Assume S is expressed by an eregex and let N be the constant given by the CSY pumping lemma. Consider w = aN baN +1 baN (N +1) . Then there is a decomposition w = x0 yx1 y . . . yxm for some m ≥ 1 and from the pumping

282

B. Carle and P. Narendran

lemma y = ap for some p ≥ 1. Since |x0 y| < N there must be at least one occurrence of y in aN . Assume there are q ≥ 1 occurrences of y in aN . By (3) from the CSY pumping lemma there must also be q occurrences of y in aN +1 as otherwise x0 y 2 x1 y 2 . . . y 2 xm ∈ / S. Let r be the number of occurrences of y in aN (N +1) and note that N (N + 1) ≥ rp ≥ 0. Now consider x0 y 2 x1 y 2 . . . y 2 xm = aN +qp baN +1+qp baN (N +1)+rp ∈ S. Then k2 (N + qp)(N + 1 + qp) = N (N + 1) + rp for some k2 . Since rp ≤ N (N + 1), N (N + 1) + rp ≤ 2(N (N + 1)). Since qp ≥ 1, (N +qp)(N +1+qp) ≥ (N +1)(N +2) > N (N +1). Thus k2 (N +qp)(N +1+qp) ≥ k2 (N + 1)(N + 2) > k2 N (N + 1). k2 N (N + 1) < 2(N (N + 1)) is only true for k2 = 1. Thus we have (N + qp)(N + 1 + qp) = N (N + 1) + rp, so rp = q 2 p2 + qp(2N + 1)

(1)

Now consider x0 y 3 x1 y 3 . . . y 3 xm = aN +2qp baN +1+2qp baN (N +1)+2rp ∈ S. Then it must be that k3 (N + 2qp)(N + 1 + 2qp) = N (N + 1) + 2rp for some k3 . But note that (N + 2qp)(N + 1 + 2qp) = N (N + 1) + 4q2 p2 + 2qp(2N + 1), whereas N (N + 1) + 2rp = N (N + 1) + 2q2 p2 + 2qp(2N + 1) by (1). Hence such a k3 cannot exist. 2 Theorem 1. EREG languages are not closed under intersection. Proof: The language S of the previous lemma is the intersection of L((a+)b(\1a)b\1+) and L((a+)b(\1a)b\2+).

2

We can show, by a reduction from the membership problem for phrase structured grammars, that Theorem 2. The following problem is undecidable: Emptiness of Intersection of Extended Regular Expressions (EIERE): Instance: Two eregexes α and β. Question: Is L(α) ∩ L(β) empty? Proof: The reduction is from the membership problem for phrase-structure grammars (MPSG), a known undecidable problem, as mentioned earlier. A phrase structure grammar is specified as G = (V, Σ, P, S) where V is a finite nonempty set called the total vocabulary, Σ ⊆ V is a finite nonempty set called the terminal alphabet , N = V − Σ is the nonterminal alphabet, S ∈ N is the start symbol and P is a finite set of rules (or productions) of the form l → r where l ∈ V ∗ N V ∗ and r ∈ V ∗ . The membership problem MPSG is defined as follows: Instance: Phrase-structure grammar G = (V, Σ, P, S) and a string w ∈ Σ ∗ Question: Is w ∈ L(G)?

On Extended Regular Expressions

283

Given an instance of MPSG, we construct an instance of EIERE as follows: For each production li → ri ∈ P let αi = #((Σ)∗) li ((Σ)∗)#\1 ri \3, for some #∈ / V , for 1 ≤ i ≤ |P |. Let α = (α1 |α2 | . . . |αn )∗. Note that the backreferences will have to be renumbered, replacing each \j in αi with \j  where j  = 4(i − 1) + j + 1. So, L(α) is the language of sequences of derivation steps (though not necessarily continuous). #w1 #w #w2 #w #w3 #w . . . #wn #wn   1   2   3    αi2 αi3 αin αi1 where each wi = xly and wi = xry for 1 ≤ i ≤ n for some x, y ∈ Σ∗ and some l → r ∈ P. We now define β to enforce derivation continuity. Consider β0 = #((Σ)∗) # \1 which matches strings of the form #wi #wi for wi ∈ Σ∗. Let β = #S(#((Σ)∗) # \2) ∗ #w. Then L(β) contains all strings of the form #S #w1 #w1 #w2 #w2 . . . #wn #wn #w for some n ≥ 0          where each underbraced segment matches β0 . Thus L(β) is the language of all continuous steps. (Not necessarily derivation steps from G.) Finally, if we take the intersection of the two languages, namely L(α) ∩ L(β), we get strings of the form #S #w1 #w1 #w2 #w2 . . . #wn−1 #wn−1 #wn          where wi = xly and wi+1 = xry for each 1 ≤ i < n; x, y ∈ Σ∗; and l → r ∈ P and S → w1 ∈ P , wn = w. That is, we get sequences of continuous derivation steps beginning at S and ending in w. Therefore, w ∈ L(G) iff L(α) ∩ L(β) = φ 2 Lemma 3. Let α be an eregex. Then for any k > 0 there are positive integers N (k) and m such that if w ∈ L(α) and |w| > N (k) then w has a decomposition w = x0 yx1 y · · · yxm (m < m) such that 1. |y| ≥ k, and 2. x0 y j x1 y j · · · y j xm ∈ L(α) for all j > 0. Proof: Let N (k) = |α|2t k where t is the number of backreferences in α. Then if |w| > N there is a substring of w of length ≥ k that matches a Kleene star in α. (Each backreference can at most double the length of the word it matches.) Let m = t + 1. Let w = x0 yz where y is the rightmost largest substring of w that matches a Kleene star. Then clearly |y| ≥ k. Let t equal the number of (direct or indirect) backreferences to any expression that contains this star. Let m = t + 1. Let z = x1 yx2 yx3 . . . xm where the multiple instances of y correspond to these backreferences. Then w = x0 yx1 yx2 y . . . yxm and clearly x0 y j x1 y j x2 y j . . . y j xm ∈ L(α) for all j ≥ 1. 2

284

B. Carle and P. Narendran

Lemma 4. The language P = { wcwR | w ∈ {a, b}∗ } satisfies the CSY pumping property. (wR stands for the reverse of w.) Lemma 5. The language P = { wcwR | w ∈ {a, b}∗ } is not an EREG language. Proof: Assume P is an EREG language. Let k = 5. Let N (k) and m be the constants given by Lemma 5. Consider w = (abaabb)N (k) c(bbaaba)N (k) . Then there is a decomposition w = x0 yx1 y · · · yxm for some m < m. By Lemma 3, |y| ≥ 5. (k = 5) Observe that (abaabb)N (k) and (bbaaba)N (k) do not share any common substrings of length ≥ 5. Therefore, y must occur to the left or the / P. 2 right of c, but not both. Consequently, x0 y 2 x1 y 2 . . . y 2 xm ∈ We now consider the Matching Problem for Extended Regular Expressions (MERE): Instance: An eregex α and a string w ∈ Σ ∗ . Question: Is (w,α) the label at the root of a valid match tree? This has been shown to be NP-complete [4]. It turns out that the problem is NP-complete even if the target alphabet is unary: Theorem 3. The matching problem for extended regular expressions is NPcomplete even when the target (subject) string is over a unary alphabet. Proof: Membership in NP follows from the earlier result. NP-hardness can be proved by a reduction from the vertex cover problem. Vertex Cover (VC) Instance: A graph G = (V, E) and a positive integer k ≤ |V |. Question: Is there a V  ⊆ V such that |V  | ≤ k and ∀(u, v) ∈ E : u ∈ V  ∨ v ∈ V  ? Given an instance of VC, construct an instance of MERE as follows: Define n = |V | and m = |E|. Without loss of generality, assume the vertices are numbered from 2 to n + 1, so V = {2,3,. . . n+1} and E ⊆ {(i, j) | 2 ≤ i ≤ n + 1, 2 ≤ j ≤ n + 1}. (Note: The n vertices are numbered from 2 to n + 1 to account for the shifting of backreferences caused by the outer parenthesis of α0 , defined below.) Let Σ = {a}. Let w = ak+|E| = ak+m . Vertex Component: Construct α as follows: Let α0 = ( ( a ) | ( a ) | ( a ) | . . . | ( a ) | 1 2

2

3

3

4

4

n

n

( a ) n+1

)∗

n+1 1

That is, α0 is n copies of (a) connected by or , and then starred. Note that α0 can be constructed in O(|V |) time. Edge Component: Assume the edges are ordered from 1 to m: et ∈ E for 1 ≤ t ≤ m. For each et = (i, j) ∈ E, let αt = (\i | \j). That is, each αt represents the tth edge via backreferences, with the backreference incremented by one to account for the outer parenthesis in α0 . Note that this can be done in O(|E|) time.

On Extended Regular Expressions

285

Finally, let α = α0 α1 α2 . . . αm . Note that α can be constructed in O(|V |+|E|) time. We now show that α matches w iff G has a vertex cover of size ≤ k. Suppose V  ⊆ V is a vertex cover for G with |V  | ≤ k. Then we can find a valid match tree for (w, α) as follows: We can safely assume that |V  | = k, since additional vertices from V can always be added to make this true. Let us start by matching k iterations of α0 , one for each v ∈ V  . For each v ∈ V  ⊆ {2,3,. . . ,n+1} match the v th option of the or in α0 on a different iteration. More specifically, if we let V  = {v1 , v2 , . . . , vk } ⊆ {2, 3, . . . , n + 1} then on the vith iteration of α0 match the vith option of the or in α0 , which will assign a to \vi . Thus, α0 matches ak . Recall that each αt = (\i | \j) for 1 ≤ t ≤ m represents edge et = (i, j). Since V  is a vertex cover for G, at least one of {i, j} is in V  . Therefore, at least one of {\i, \j} is already defined in our match tree. If \i is defined, match it. Otherwise match \j. Furthermore, any defined backreference \2, \3, . . . \n + 1 can only match a single a, so α1 α2 . . . αm matches am . Therefore, α = α0 α1 α2 . . . αm matches ak am = ak+m = w. Conversely, suppose (w, α) = (ak+m , α) is the root of a valid match tree. Then we can find a vertex cover V  ⊆ V for G with |V  | ≤ k as follows: To begin, let V  = φ. Since there is a match for α, each of α1 α2 . . . αm must be defined. Thus, each αt for 1 ≤ t ≤ m matches a single a. For each αt = (\i | \j), if \i is matched, let V  = V  ∪ {i}, else if \j is matched, let V  = V  ∪ {j}. Recall that α1 α2 . . . αm matches am . Thus, V  is a vertex cover for G since it contains one vertex from each edge (from each corresponding αi ). Then α0 must match the remaining ak . Therefore, there can be at most k unique backreferences defined, which means there can be at most k distinct vertices in V  . Therefore, |V  | ≤ k and G has a vertex cover of size ≤ k. Thus α matches w iff G has a vertex cover of size ≤ k. Furthermore, the reduction can be done in O(|V | + |E|) = O(|V |2 ) time. Therefore, MERE is NP-complete. 2 Remark: Notice that this proof crucially uses the (semantic) assumption that unassigned backreferences are not set to the empty string. The result can also be proved without using this ‘feature’. However, the proof is a bit more complicated and we omit it here.

4

Extended Multi-Pattern Languages (EMPL)

Let Σ be a finite set of terminals {a1 , . . . , an } and V = {x1 , x2 , . . .} be an infinite set of variables (Σ ∩V = ∅). Then a pattern is a non-null finite string over Σ ∪V . We use the terms erasing (E) and non-erasing (NE) pattern languages in the following sense. Let HΣ,V be the set of morphisms h : (Σ, V )∗ → (Σ, V )∗ . The E pattern language generated by a pattern π is defined as LE (π) = {w ∈ Σ ∗ | ∃h ∈ HΣ,V ((∀a ∈ Σ : h(a) = a) ∧ w = h(π))} The N E pattern language generated by a pattern π is defined as {w ∈ Σ ∗ | ∃h ∈ HΣ,V ((∀a ∈ Σ : h(a) = a) ∧ (¬∃v ∈ V : h(v) = λ) ∧ w = h(π))} and denoted as LN E (π).

286

B. Carle and P. Narendran

Given a set of patterns {π1 , π2 , . . . , πn }, the E-multi-pattern language (MPLn  LE (πi ). Similarly, the NE-multi-pattern language (MPL-NE) E) they define is i=1

defined by {π1 , π2 , . . . , πn } is

n  i=1

LN E (πi ).

This notion was extended by Nagy [2] to that of EMP expressions in the following way: Let {π1 , π2 , . . . , πn } be a set of patterns. Each pattern πi (1 ≤ i ≤ n) is an EMP expression. If γ and δ are EMP expressions then γ ∨ δ is also an EMP expression (using the operation union), γ · δ is also an EMP expression (using the operation concatenation), γ ∗ is also an EMP expression (using the operation Kleene star). In other words, extended multi-pattern (EMP) expressions are obtained from the patterns π1 , . . . , πn by using finitely many regular operators. The EMP expressions which can be obtained without using union (∨) are called star-pattern expressions (EMSP expressions). The erasing extended multi-pattern language defined by an EMP expression can be obtained from the E pattern languages in the following way: LE (γ ∨ δ) = LE (γ) ∪ LE (δ) (using the operation union), LE (γ · δ) = LE (γ) · LE (δ) (using the operation concatenation), LE (γ ∗ ) = (LE (γ))∗ (using the operation Kleene star). We then define EMPL-E (Extended Multi-Pattern Languages – Erasing) to be the family of erasing extended multi-pattern languages 2 . The non-erasing extended multi-pattern language defined by an EMP expression can be obtained from the NE pattern languages in the following way: LN E (γ ∨ δ) = LN E (γ) ∪ LN E (δ) (using the operation union), LN E (γ · δ) = LN E (γ) · LN E (δ) (using the operation concatenation), LN E (γ ∗ ) = (LN E (γ))∗ (using the operation Kleene star). Let EMPL-NE (Extended Multi-Pattern Languages – Non-Erasing) stand for the family of non-erasing extended multi-pattern languages. It is not hard to see that EMPL-E (resp. EMPL-NE) is the regular closure [7,8] of the family of E pattern (resp. NE pattern) languages. If γ is an EMSP expression then LE (γ) is an erasing extended multi-starpattern language. Let EMSPL-E be the family of erasing extended multi-starpattern languages. Similarly, if γ is an EMSP expression then LN E (γ) is a non-erasing extended multi-star-pattern language. Let EMSPL-NE be the family of non-erasing extended multi-star-pattern languages. Finally, let EMPL = EMPL-E ∪ EMPL-NE, and likewise, let EMSPL = EMSPL-E ∪ EMSPL-NE. Now two questions arise: Question 1: Does EMPL-E = EMPL-NE (= EMPL)? Question 2: Does EMSPL-E = EMSPL-NE (= EMSPL)? 2

Note that this is not the same as the family PL(REG, REG) defined in [6].

On Extended Regular Expressions

287

We answer Question 1 affirmatively and Question 2 negatively. Lemma 6. The language L = { xbx | x ∈ {a, b}∗ } ∈ EMSPL-E. Proof: Let Σ = {a, b} and v ∈ V . Then α = vbv is an EMSP expression and LE (α) = L. 2 Lemma 7. The language L = { xbx | x ∈ {a, b}∗ } ∈ / EMSPL-NE. Proof: (by contradiction). Assume L is an NE star-pattern language. Then there is an NE star-pattern expression α such that LN E (α) = L. α cannot contain the union operator since it is an NE star-pattern expression. Clearly α cannot have a star as its outer-most operator. Otherwise, α would match λ, which is not in L. Define a language to be non-trivial if and only if it is neither empty nor the singleton set {λ}. Claim: L is not the concatenation of two non-trivial languages. Proof: Assume the contrary and let L = A ◦ B with A and B non-trivial. Without loss of generality assume that b ∈ B. Hence every non-empty string in A must be of the form ubbu for some u ∈ {a, b}∗. Now consider the string aba which belongs to L. aba has to be in B since no non-empty prefix of it can be 2 in A. But then the word equation ubbuaba =? xbx has no solution. Since α cannot be a single pattern either, the result follows3 . Lemma 8. EMSPL-E =

EMSPL-NE.

Proof: The language L of Lemma 6 (and 7) is in EMSPL-E, but is not in EMSPL-NE. 2 Lemma 9. EMPL-NE = EMPL-E. Proof: This follows from the results of [3]. We omit the proof.

2

Lemma 10. Every EMPL language is semi-linear. Proof-sketch: Every language in MPL is semi-linear [3]. The family of semilinear languages is closed under union, concatenation and star. 2 Lemma 11. The EREG language L((a*)b(\1)) = {ai bai | i ≥ 0} is not an EMPL. Proof-idea: If any of the patterns used in the defining expression contains a variable, then it can be replaced with bb. 2 Theorem 4. EMPL ⊂ EREG. 3

Thus without backreferences the analogous result to Theorem 17 of [2] does not hold.

288

B. Carle and P. Narendran

Proof-idea: EREG ⊆ EMPL follows from the previous lemma. EMPL ⊆ EREG can be shown as follows: Given an EMP expression γ over terminal alphabet Σ = {a1 , . . . , an }, we can construct an equivalent EREG pattern α. Let {π1 , π2 , . . . , πn } be the set of patterns that occur within γ. For each pattern πi (1 ≤ i ≤ n), replace the first occurrence of a variable within πi with ((a1 |a2 | . . . |an )∗), where k is the index of the outer left parenthesis we are adding. Replace each subsequent occurrence of the same variable with \k. 2 Lemma 12. The following problem is undecidable: Instance: Two sets of patterns P1 and P2 . Question: Is (LE (P1 ))∗ ⊆ (LE (P2 ))∗ ? Proof idea: The problem of deciding, given two patterns α and β, whether LE (α) ⊆ LE (β) is known to be undecidable [9]. Let # be a new symbol, not present in the alphabet Σ of α and β. Let Ω = Σ ∪ {#}. Now form the sets of patterns Γ = {#α#} and Δ = {#β#, #x1 #x2 #}. Claim 1: (LE (Γ ))∗ ⊆ (LE (Δ))∗ over Ω if and only if LE (α) ⊆ LE (β) over Σ. Claim 2: (LE (Γ ))∗ ⊆ (LE (Δ))∗ if and only if (LE (Γ ∪ Δ))∗ = (LE (Δ))∗ . Thus the equivalence problem for EMSPL-E is undecidable.

2

The same technique will work for EMSPL-NE, except that Δ will have to be defined a little differently, as {#β#, #x1 #x2 #, ##x2 #, #x1 ##, ###}. It can also be shown that Lemma 13. For every EMP of the form α∗ (i.e., with star as the outermost operator), there is an EMSP γ such that LN E (γ) = LE (α∗ ). Proof-sketch: Since the families EMPL-E and EMPL-NE are the same, there must be an EMP β such that LN E (β) = LE (α). It can be shown (see e.g., [10]) 2 that an expression equivalent to β ∗ that does not use ∨ can be found. Theorem 5. The equivalence problem for EMSPL-NE is undecidable. This settles an open problem given in [2]. Acknowledgements. We thank Colin Scheriff for work on an earlier version of the paper [11] and in particular on the proof of Lemma 3. We also thank the referees for their insightful comments.

References 1. Cˆ ampeanu, C., Salomaa, K., Yu, S.: A formal study of practical regular expressions. Int. J. Found. Comput. Sci. 14, 1007–1018 (2003) 2. Nagy, B.: On the language equivalence of NE star-patterns. Inf. Process. Lett. 95, 396–400 (2005)

On Extended Regular Expressions

289

3. Kari, L., Mateescu, A., Paun, G., Salomaa, A.: Multi-pattern languages. Theor. Comput. Sci. 141, 253–268 (1995) 4. Aho, A.V.: Algorithms for finding patterns in strings. In: Handbook of Theoretical Computer Science. Algorithms and Complexity (A), vol. A, pp. 255–300. MIT Press, Cambridge (1990) 5. Gallier, J.H.: Logic for Computer Science: Foundations of Automatic Theorem Proving. Harper & Row (1986) 6. Dumitrescu, S., P˘ aun, G., Salomaa, A.: Languages associated to finite and infinite patterns. Rev. Roum. Math. Pures Appl. 41, 607–625 (1996) 7. Bertsch, E., Nederhof, M.J.: Regular closure of deterministic languages. SIAM J. Comput. 29, 81–102 (1999) 8. Kutrib, M., Malcher, A.: Finite turns and the regular closure of linear context-free languages. Discrete Applied Mathematics 155, 2152–2164 (2007) 9. Jiang, T., Salomaa, A., Salomaa, K., Yu, S.: Decision problems for patterns. J. Comput. Syst. Sci. 50, 53–63 (1995) 10. Nagy, B.: A normal form for regular expressions. In: Eighth International Conference on Developments in Language Theory (DLT 2004), Auckland, New Zealand (2004), www.cs.auckland.ac.nz/CDMTCS/researchreports/252dlt04.pdf 11. Carle, B., Narendran, P., Scheriff, C.: On extended regular expressions. In: Twentyfirst International Workshop on Unification (UNIF 2007), Paris, France (June 2007)

Multi-tilde Operators and Their Glushkov Automata Pascal Caron, Jean-Marc Champarnaud, and Ludovic Mignot LITIS, University of Rouen, France {pascal.caron,jean-marc.champarnaud}@univ-rouen.fr, [email protected]

Abstract. Classical algorithms convert arbitrary automata into regular expressions that have an exponential size in the size of the automaton. There exists a well-known family of automata, obtained by the Glushkov construction (of an automaton from an expression) and named Glushkov automata, for which the conversion is linear. Our aim is to extend the family of Glushkov automata. A first step for such an extension is to define a new family of regular operators and to check that the associated extended expressions have good properties: existence of normal forms, succinctness with respect to equivalent simple expressions, and compatibility with Glushkov functions. This paper addresses this first step and investigates the case of multi-tilde operators.

1

Introduction

The framework of this paper is the translation from a regular expression into a finite automaton as well as the inverse translation. Numerous studies have been devoted to this topic, leading to polynomial algorithms for both sides of the conversion (the first ones are due to McNaughton and Yamada [1] for both constructions, to Glushkov [2] for constructing an automaton, and to Brzozowski and McCluskey [3] for constructing an expression). Many research works have focused on producing a small automaton (as efficiently as possible). For example there exist quadratic algorithms1 for converting an expression into its Glushkov automaton [6], its Antimirov automaton [7] or its follow automaton [8]. Moreover, the Glushkov automaton of an expression with n occurences of symbols (we say that its alphabetic width is equal to n) has only n + 1 states; the Antimirov automaton and follow automaton (that are quotients of the Glushkov automaton) have at most n + 1 states. On the other hand, classical algorithms compute expressions the size of which is exponential with respect to the number of states of the automaton and studies that address the problem of producing a short expression are not so many. Let us cite the heuristic-based approaches presented in [9] and in [10] that both 1

The fastest conversion from an expression into an automaton is the O(n(log(n))2 ) algorithm [4] based on the Common Follow Sets introduced by [5]. The number of states of the resulting automaton is a polynomial of n.

A.H. Dediu, A.M. Ionescu, and C. Martín-Vide (Eds.): LATA 2009, LNCS 5457, pp. 290–301, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Multi-tilde Operators and Their Glushkov Automata

291

aim at reducing the size of the expression computed by the state elimination algorithm [3]. Recently, several questions were raised in [11] concerning the descriptional complexity of regular expressions and more precisely the effect of regular operations on this complexity. An answer is given in [12], concerning the operation of removing the empty word that is proved to incur at most a quasilinear increase in regular expressions. More recently, exponential lower bounds have been provided for the intersection and shuffle operations as well as a doublyexponential lower bound for the complementation [13], [14]. In [15] it is shown that quadratic size expressions can be computed for language quotient operations and cubic size expressions for circular shift operation. In this paper, we also address the problem of computing short expressions, and we focus on a specific kind of conversion based on Glushkov automata. Actually the particularity of Glushkov automata is the following: any regular expression of width n can be turned into its Glushkov (n + 1)-state automaton; if a (n + 1)-state automaton is a Glushkov one, then it can be turned into an expression of width n. The latter property is based on the characterization of the family of Glushkov automata presented in [16]. Our aim is to extend this family according to the following schema. In a first step, we design new families of regular operators supporting Glushkov computation and we check that they lead to extended expressions significantly shorter than equivalent simple expressions. In a second step, we give an algorithm to turn a Glushkov (n+1)-state automaton into an extended expression of width n. Presently, we have completed the study of two new families of operators: multi-bars and multi-tildes. The first step includes a large amount of technical work, in particular for investigating the properties of extended expressions and for determining normal forms. It is the reason why multi-bar presentation in [17] and multi-tilde presentation in this paper only address this first step. Notice that although multi-bar and multi-tilde operators are based on dual elementary operations: eliminating (resp. adding) the empty word from (resp. to) the language of an expression, there exists no obvious way allowing to go from multi-bar properties to multi-tilde ones and respective proofs are quite different. It is the reason why two separate studies have been presented. Let us point out that it is necessary to consider extended expressions mixing operators from both of these families for investigating the second step. The following section recalls fundamental notions concerning regular expressions and finite automata. In Section 3 we introduce the family of multi-tilde operators and we study their properties in Section 4. In Section 5 we introduce the notion of an expression in tilde normal form and we compute the Glushkov functions of multi-tilde operators in Section 6.

2

Preliminaries

Let us first review basic notions concerning regular expressions and finite automata. For a comprehensive treatment of this domain, references [18], [19] can be consulted.

292

P. Caron, J.-M. Champarnaud, and L. Mignot

Let Σ be an alphabet and ε be the empty word. Let E be a regular expression over Σ. The language denoted by the expression E is L(E). The expression E is a simple regular expression if the only operators used are union (+), concatenation (·) and Kleene closure (∗). The alphabetical width |E| of an expression E is the number of occurences of symbols in E. An expression in which every symbol occurs only once is called a linear expression. The expression E is nullable if its language contains the empty word. Let P = E1 · · · En be a concatenation of n expressions. We will denote by Ei,j the factor Ei · · · Ej of P and we will assume that L(Ei,j ) = {ε} when i > j. Two factors Ei,j and Ei ,j  of P overlap if and only if 1 ≤ i ≤ i ≤ j ≤ j  ≤ n. We will denote by E1:n the list (E1 , . . . , En ). Given a set S, we denote by Card(S) the number of elements of S. In the following, we will focus on new operators fitting with the Glushkov automaton computation. The main interest of the Glushkov automaton of a linear expression E is to provide a one-to-one mapping from the set of symbols of the expression onto the set of states of the automaton. Glushkov [2] and McNaughton and Yamada [1] have defined independently the Glushkov automaton of an expression E and proved that it recognizes the language L(E). We recall here this definition. In order to specify their position in the expression, symbols are subscripted following the order of reading. For example, starting from E = (a + b)a∗ , one obtains the linear expression E = (a1 + b2 )a∗3 . The set of positions of the expression is denoted by Pos(E). The mapping h: Pos(E) → Σ gives the symbol that is at a given position. In the previous example, we have h(2) = b. Four functions are defined in order to compute an automaton: First(E) is the set of initial positions of words of L(E), Last(E) is the set of final positions of words of L(E) and Follow(E, k) is the set of positions immediately following the position k in a word of L(E). The Null(E) function is defined as {ε} if E is nullable, ∅ otherwise. These four functions allow us to define the Glushkov automaton ME of E as follows: ME = (Σ, Q, {0}, F, δ) where Q = Pos(E) ∪ {0} is the set of states and 0 is not in Pos(E). The set of final states is F = Last(E) if Null(E) = ∅, F = Last(E) ∪ {0} otherwise, and the set of transitions is defined by δ = {(x, h(y), y) | x ∈ Pos(E) and y ∈ Follow(E, x)} ∪ {(0, h(y), y) | y ∈ First(E)}.

3

The Family of Multi-tilde Operators

Given a list E1:n of regular expressions, we study the family of languages denoted by the expressions obtained from the expression P = E1,n by simultaneously adding the empty word to several (and possibly overlapping) factors Ei,f of P . Throughout this paper we will assume that for all 1 ≤ k ≤ n the expression Ek is not equal to the empty word nor to the empty set. 3.1

Multi-tilde Definition

We first define a new operator, called tilde, that can be applied to any regular expression and that is such that L( E ) = L(E) ∪ {ε}. A multi-tilde operator

Multi-tilde Operators and Their Glushkov Automata

293

applies to a list E1:n of regular expressions and allows us to apply the tilde operator to several factors of the expression E1,n . The position of these factors is retrieved from a set of couples T = ((ik , fk ))1≤k≤Card(T ) such that for all k ∈ 1, Card(T ), 1 ≤ ik ≤ fk ≤ n. Such an operator based on a list T is denoted by PT and a couple in T is called a tilde. By convention, the list T is 2 finite and ordered according to the lexicographic order if empty,  over N and,  we assume that PT (E1:n ) = E1,n . For example, if T = (1, 2)(2, 3) , the effect of the operator PT on the list (E1 , E2 , E3 ) is to add the empty word to the factors E1 · E2 and E2 · E3 . We first examine a basic case where the language L(PT (E1:n )) is easily defined. Definition 1. A finite list of couples S is said to be free if and only if, ∀(i, f ), (i , f  ) ∈ S, we have i, f  ∩ i , f   = ∅. In the case where a multi-tilde is defined by a free list S, all the factors defined by the list can simultaneously be made nullable (by adding the empty word to each of them) and thus the language is defined as follows: Definition 2. Let E1:n be a list of expressions. Let S = ((ik , fk ) | ∀k, 1 ≤ ik ≤ fk ≤ n)1≤k≤s=Card(S) be a free list of couples. The language L(PS (E1:n )) is defined as follows: L(PS (E1:n )) = L(E1,i1 −1 ) · (L(Ei1 ,f1 ) ∪ {ε}) · L(Ef1 +1,i2 −1 ) · · · (L(Eis ,fs ) ∪ {ε}) · L(Efs +1,n ) The case of a non-free list can be illustrated by the following example.   Example 1. We consider the list T = (1, 2)(2, 3)(3, 4) and the expression E = PT (a, b, c, d), that can be representedby a b c d . Since the sublist S = (1, 2)(3, 4) is a free one, the factors ab and cd can simultaneously be made nullable by adding the empty word to each of them. On the other hand, it is not possible to simultaneously substitute ab + ε to the factor ab and bc + ε to the factor bc. The same reasoning applies to the factors bc and cd. Therefore we consider all the free sublists of T and define the language L(E) as the union of their languages. 3 c i

c 2

a

b

d 4

d

1

  Fig. 1. An automaton recognizing the language L P(1,2)(2,3)(3,4) (a, b, c, d)

In our example, we get: L(E) = L( a · b · c · d) ∪L(a · b · c · d) ∪L(a · b · c · d ) ∪L( a · b · c · d ) and thus L(E) = {abcd, cd, ab, ad, ε}.

294

P. Caron, J.-M. Champarnaud, and L. Mignot

Finally, for an arbitrary list T of couples, L(PT (E1:n )) is defined as follows: Definition 3. Let E1:n be a list of expressions. Let T = ((ik , fk ) | ∀k, 1 ≤ ik ≤ fk ≤ n)1≤k≤Card(S) be a list of couples. Let T be the set of all the free sublists of T . Then the language L(PT (E1:n )) is defined as follows:    L(PT  (E1:n )) L PT (E1:n ) = T  ∈T

This new family of multi-tilde operators leads us to consider the following extension of regular expressions. Definition 4. An extended to multi-tilde regular expression (EMTRE) is inductively defined by: E=∅ E=ε E = a with a ∈ Σ E = PT (E1:n ) where 3.2

E = F + G where F and G are two EMTREs E = F · G where F and G are two EMTREs E = F∗ where F is an EMTRE E1:n is a list of (not equal to ∅ nor ε) EMTREs

Reduction Power of Multi-tildes

Multi-tildes, similarly to multi-bars [17] lead to a reduction of the alphabetic width that is generally more important than by a straightforward factorization of an equivalent simple regular expression. This fact is illustrated by Example 2. Example 2. Let E = a b c be an EMTRE, with |E| = 3. The language L(E) is recogc nized by the automaton of Figa c b ure 2. Any equivalent simple i 1 2 3 regular expression is wider than Fig. 2. An the lan  automaton recognizing E; for example, the width of the  (a, b, c) guage L P  (1,2)(2,3) expression E = a(bc + ε) + c is equal to 4. Example 2 can be generalized by considering  the language Ln denoted  by the EMTRE En = PTn (a1 , . . . , an ), with Tn = (1, 2)(2, 3) . . . (n − 1, n) . The importance of the multi-tilde operators can be shown by comparing the width of the generalized expression En (that is equal to n) and the minimal width of an equivalent simple expression En . It is well known that there exists no polynomial algorithm for computing a regular expression of minimal width denoting a given regular language [20], even if this language is a finite one. Therefore we proceed as follows: we start from E3 = a1 (a2 a3 + ε) + a3 (that can be easily shown to be an expression of minimal width), and we apply a specific procedure to construct  . Although it is not proved that the alphabetic width of En is En from En−1 minimal, this expression seems to be a good candidate for minimality. Moreover, it can be shown that the expression En has an exponential width with respect to n. Let us remark that the alphabet of the languages (Ln )n≥3 does not have a constant size.

Multi-tilde Operators and Their Glushkov Automata

4

295

Properties of Multi-tildes

In this section we first introduce some notation and then state properties of multi-tilde operators that will be useful in the next sections. 4.1

Definitions and Notation

Let E = PT (E1:n ) be an EMTRE. Let t = (i, f ) ∈ T ; we set Ranks(t) = i, f . Let k ∈ i, f ; we set Tildes(k) = {(i, f ) ∈ T | i ≤ k ≤ f }. A tilde (i, f ) ∈ T is overlapping if and only if there exists (i , f  ) ∈ T such that i < i ≤ f  < f or i < i ≤ f < f  . A tilde t = (i, f ) ∈ T is included if and only if there exists a tilde (i , f  ) ∈ T \ {t} such that i ≤ i ≤ f ≤ f  . A tilde in T is overhanging if and only if it is not overlapping. We say that T is overlapping if and only if every tilde of T is overlapping. We say that T is continuous if and only if for all k ∈ 1, n − 1, Tildes(k) ∩ Tildes(k + 1) = ∅. We say that T has a minimal arity if and only if ∀k ∈ 1, n − 1, Tildes(k) = Tildes(k + 1). Definition 5. Let i, f ∈ 1, n | i ≤ f . The linear EMTRE E = PT (E1:n ) is said to be (i, f )-nullable if and only if L(E1,i−1 ) · L(Ef +1,n ) ⊂ L(E). Let S be a list of couples. The expression E is said to be S-nullable if and only if it is (i, f )-nullable for all (i, f ) ∈ S. Definition 6. A tilde t = (i, f ) ∈ T is useful for a linear EMTRE E = PT (E1:n ) if and only if the languages L(PT (E1:n )) and L(PT \{t} (E1:n )) are different. The list T is useful if and only if every tilde of T is useful. Let us consider a linear EMTRE E = PT (E1:n ). Let w = w1 · · · wn be a word such that for all k ∈ 1, n, wk ∈ L(Ek ) ∪ {ε}. Let us suppose that there exists a factor wi · · · wf = ε. This factor has a left (resp. right ) ε-extension in w if there exists k = i − 1 (resp. k = f + 1) such that wk = ε. If a factor of w has no ε-extension, then, it is ε-maximal in w. 4.2

Nullability Properties

Lemma 1. Let E = PT (E1:n ) be a linear EMTRE and w ∈ L(E). Then there exists a unique decomposition w = w1 · · · wn such that ∀k ∈ 1, n, wk ∈ L(Ek ) ∪ {ε}. Lemma 2. Let E = PT (E1:n ) be a linear EMTRE. Let i, f ∈ 1, n | i ≤ f . The expression E is (i,  f )-nullable if and only if there exists a free list S = (ik , fk ) | k ∈ 1, Card(S) of couples satisfying the following conditions: - i1 = i, fCard(S) = f and ∀k ∈ 1, Card(S) − 1, fk = ik+1 − 1, - ∀(ik , fk ) ∈ S, we have: (ik , fk ) ∈ T or Eik ,fk is nullable. Proof. We set L = L(E1,i−1 ) · L(Ef +1,n ). (1) ⇐ (2) : let S be a list satisfying the previous conditions. We consider the partition (S1 = S ∩ T, S2 = S \ S1 ) of S. Since S is free, S1 is a free sublist of

296

P. Caron, J.-M. Champarnaud, and L. Mignot

T . By Definition 3 it holds that L(PS1 (E1:n )) ⊂ L(E). Moreover since for every couple (ik , fk ) in S2 the expression Eik ,fk is nullable, we have L(PS1 ∪S2 (E1:n )) = L(PS1 (E1:n )). Finally, L ⊂ L(PS (E1:n )) and the expression E is (i, f )-nullable. (1) ⇒ (2) : we suppose that E is (i, f )-nullable. By Definition 5, L = L(E1,i−1 )· L(Ef +1,n ) ⊂ L(E). Let w = w1 · · · wi−1 · wf +1 · · · wn be a word in L such that for all k ∈ 1, i − 1 ∪ f + 1, n, wk ∈ L(Ek ) \ {ε}. Since L ⊂ L(E), there exists a free subslist S of T such that w ∈ L(PS (E1:n )). Let (i1 , f1 ) (resp. (is , fs )) be the least (resp. the greatest) element in the ordered list S and (ik+1 , ifk+1 ) be the least element greater than (ik , fk ). Let us consider the set V of couples defined by: V = {(i, i1 − 1), (fs + 1, n)} ∪ {(fk + 1, ik+1 − 1) | (ik , fk ), (ik+1 , fk+1 ) ∈ T }. If S = ∅ we set V = V ∪ {(i, f )}. There exists no couple (i , f  ) in V satisfying i ≤ i ≤ f  ≤ f and ε ∈ / L(Ei ,f  ). Otherwise, by Definition 3 the word w would not be in L(PS (E1:n )). Therefore there exist only two cases: either Ei ,f  is nullable for any couple in V , or for all k ∈ 1, Card(S) − 1, fk = ik+1 , i1 = i and fCard(S) = f . In these two cases, we can construct a list of couples satisfying the conditions of the lemma.   Proposition 1. Let E = PT (E1:n ) be a linear EMTRE. Let w = w1 · · · wn be a word such that  for all j ∈ 1, n, wj ∈ L(Ej ) ∪ {ε}. Let S = (ik , fk ) | k ∈ 1, Card(S) be a free list such that ∀k ∈ 1, Card(S), wik · · · wfk is an ε-maximal factor in w. Then the three following conditions are equivalent: (1) L(PS (E1:n )) ⊂ L(E), (2) E is S-nullable, (3) w ∈ L(E). Proof. (1) ⇒ (2) : according to Definition 2, ∀(i, f ) ∈ S, L(P((i,f )) (E1:n )) ⊂ L(PS (E1:n )) ⊂ L(E). Thus, for each (i, f ) of S, E is (i, f )-nullable and then by definition E is S-nullable. (2) ⇒ (3) : according to Lemma 2, for each couple (ik , fk ) of S, there exists a list Sk and a partition (S1k , S2k ) of Sk such that S1k = Sk ∩T and S2k = Sk \S1k . Since S is free, the list S  = S1k is free too and S  ⊂ T . Following k∈1,Card(S)

 Definition 3, L(P  S (E1:n )) ⊂ L(E). Moreover, since for every couple (ik , fk )  of S = S2k , the factor Eik ,fk is nullable and since ∀(ik , fk ) ∈

k∈1,Card(S)

S  , ik , fk  ∩ ik , fk  = ∅, we have L(PS  ∪S  (E1:n )) = L(PS  (E1:n )). Finally we get L(PS (E1:n )) ⊂ L(E) and then w ∈ L(E). (3) ⇒ (1) : we suppose that w ∈ L(E). Since for all k ∈ 1, Card(S), wik · · · wfk is an ε-maximal factor in w, we have w ∈ L(PS (E1:n )). By Definition 2, there exists a free sublist S  of T such that w ∈ L(PS  (E1:n )). Let w = w1 · · · wn be a word in L(PS (E1:n )) such that w ∈ / L(PS  (E1:n )). It implies that there    exists an ε-maximal wi · · · wf in w , such that PS  (E1:n ) is not (i, f )-nullable.  By hypothesis, there exists k ∈ 1, Card(S) such that ik ≤ i ≤ f ≤ fk and thus PS  (E1:n ) is not (ik , fk )-nullable. Contradiction with w ∈ L(PS  (E1:n )). Finally, L(PS (E1:n )) ⊂ L(PS  (E1:n )) ⊂ L(E).  

Multi-tilde Operators and Their Glushkov Automata

297

Corollary 1. Let E = PT (E1:n ) be a linear EMTRE. Let i, f ∈ 1, n with f ≥ i. Let w = w1 · · · wi−1 · wf +1 · · · wn with for all k ∈ 1, i − 1 ∪ f + 1, n, wk ∈ L(Ek ) \ {ε}. The following two conditions are equivalent: (1) w ∈ L(E), (2) E is (i, f )-nullable. The following lemma will be useful to construct a normal form for E. Lemma 3. Let E = PT (E1:n ) be a linear EMTRE. A tilde t = (i, f ) ∈ T is useful for E if and only if PT \{t} (E1:n ) is not (i, f )-nullable.

5

Definition of Multi-tildes in Tilde Normal Form

Two multi-tilde operators operating on a same list of expressions with distinct lists of couples can recognize the same language. This fact can be illustrated by the following example. Example 3. Let E1 = a b c d and E2 = a b c d , that are respectively based on the set of tildes: {(1, 2)(2, 2)(2, 3)(3, 3)(3, 4)} and {(1, 2)(2, 2)(3, 3)(3, 4)}. It can be checked that the languages L(E1 ) and L(E2 ) are equal. We define a set of necessary and sufficient conditions that allow us to define a normal form for multi-tilde operators. Definition 7. Let E = PT (E1:n ) be a linear EMTRE. The expression E is said to be in tilde normal form (TNF) if and only if the following properties are checked: - T is useful for E, - either T is overlapping or Card(T ) = 1, - T is continuous, - the arity of T is minimal. An expression satisfying these conditions is denoted by E = PT (E1:n ). Example 4. The syntax tree of the expression E3 = (a · b ) · ( c · d) is represented by Figure 3. · It can be checked that this expression satisfies each condiP(1,1) P(1,1) tion of Definition 7 and that it is equivalent to the expressions · · E1 and E2 of Example 3. Let us a P(1,1) d P(1,1) remark that the graphical representations of E2 and E3 are very b c close, although the syntax trees Fig. 3. The expression E3 is in TNF are different.

298

P. Caron, J.-M. Champarnaud, and L. Mignot

An EMTRE is said to be in TNF if and only if its linearized version E is in TNF. Definition 8. An extended to normal tilde regular expression(ETRE) is inductively defined as follows: E=∅ E=ε E = a with a ∈ Σ

E = F + G with F and G two ETREs E = F · G with F and G two ETREs E = F∗ with F an ETRE

E = PT (E1:n ) where E1:n is a list of (not equal to ∅ nor ε) ETREs We now prove that the set of conditions of Definition 7 allow us to define a normal form. Lemma 4. Let E = PT (E1:n ) be an ETRE. Then L(E) = ∅ and L(E) = {ε}. Proposition 2. Let E1 = PT1 (E1:n ) and E2 = PT2 (E1:n ) be two linear ETREs. The two following conditions are equivalent: (1) L(E1 ) = L(E2 ), (2) T1 = T2 . Proof (1) ⇒ (2) : Let t = (i, f ) ∈ T1  T2 such that the length lt = f − i + 1 of t be minimal. Let us suppose that t ∈ T1 . Then, E1 is (i, f )-nullable. Let us suppose that E2 is (i, f )-nullable. If t ∈ T2 , we have a contradiction with t ∈ T1  T2 . If ε ∈ L(Ei,f ), we have a contradiction with the utility of t for E1 (see Lemma 3). If there exist several couples allowing E2 to be (i, f )-nullable, and if there exists no tilde (i , f  ) ∈ T2 such that i ≤ i ≤ f  < f or i < i ≤ f  ≤ f , the situation is similar as in the previous case. If there exists a tilde, then we can choose it not to be in T1 (if there does not exist such a tilde, then the combination of tildes and of nullable factors of E2 make the tilde t useless for E1 ). Contradiction with the minimality of lt . And then, as the expression E1 is (i, f )-nullable while the expression E2 is not, their languages are disjoint. (1) ⇐ (2) : Trivial.

 

Proposition 3. Let E = PT (E1:n ) be an EMTRE. Then, there exists an ETRE E  such that L(E) = L(E  ).

6

Glushkov Functions

Definition 9. Let E = PT (E1:n ) be an ETRE with Card(T ) = m and T =   (ik , fk ) k∈1,m . The Glushkov functions associated to the PT operator are defined as follows: (9.1) Pos(E)=

n  k=1

Pos(Ek )

Multi-tilde Operators and Their Glushkov Automata

299



ε if E is (1, n)-nullable ∅ otherwise  (9.3) First(E)=First(E1 ) ∪ First(Ek ) k s.t. E is (1,k-1)-nullable  (9.4) Last(E)=Last(En ) ∪ Last(Ek ) k s.t. E is (k+1,n)-nullable (9.5) ∀x ∈ Pos(E), ⎧ ∃k ∈ 1, n | x ∈ Pos(Ek ). Then: Follow(x, Ek ) if x ∈ / Last(Ek ) ⎪ ⎪ ⎪ ⎪ or if x ∈ Pos(En ) ⎨ ) ∪ Follow(x, Ek+1 )∪ Follow(x, E)= Follow(x, Ek ⎪ ⎪ ⎪ First(Ek ) otherwise ⎪ ⎩  k s.t. E is (k+1,k’-1)-nullable (9.2) Null(E)=

Proposition 4. Let E = PT (E1:n ) be an ETRE and let GE be its Glushkov automaton. Then, we have L(E) = L(GE ). Proof. The definition of Glushkov functions for +, · and ∗ operators induces that: (P1) ax ∈ ΣE ⇔x ∈ Pos(E) {ε} if and only if ε ∈ L(E) (P2) Null(E) = ∅ otherwise (P3) ∃w = ax · w ∈ L(E) ⇔ x ∈ First(E) (P4) ∃w = w · ax ∈ L(E) ⇔ x ∈ Last(E) (P5) ∃w = w · · · ax · ax · · · w ∈ L(E) ⇔ x ∈ Follow(E, x). Let us prove that Propositions (P1) to (P5) are still true when extending Glushkov functions to the PT operator. (P1) Pos(E): ax ∈ ΣE ⇔ ∃k ∈ 1, n | ax ∈ ΣEk ⇔ x ∈ Pos(E). (P2) Null(E): According to Corollary 1, we have: ε ∈ L(E) ⇔ E is (1, n)nullable. Thus, the extension of the Null(E) function is correct. (P3) First(E): (⇒) According to Lemma 4, we have L(E) = ∅ and L(E) = ε. Let w = ax · w ∈ L(E) with ax ∈ ΣE . Let k be such that ax ∈ ΣEk , which means that x ∈ Pos(Ek ). Then, there exists ax · wk ∈ L(Ek ). Thus, we have x ∈ First(Ek ). If k = 1, following Definition 9.3, x ∈ First(E). Otherwise, it implies that w = w1 · · · wk−1 · wk · wk+1 · · · wn with wk = ax · wk and w1 · · · wk−1 = ε, then w1 · · · wk = ε. According to Proposition 1 and as w1 · · · wk−1 is ε-maximal, there exists a free list S which contains the couple (1, k − 1) such that E is S-nullable. Thus, E is (1, k − 1)-nullable and following Definition 9.3, x ∈ First(E). (⇐) Suppose that x ∈ First(E) and let k ∈ 1, n such that x ∈ First(Ek ). We know that ∀i ∈ 1, n, L(Ei ) = ∅ and L(Ei ) = {ε} according to Definition 8. Suppose that w = wk · · · wn with ∀i ∈ k, n, wi ∈ L(Ei ) and wi = ε. If k = 1, w ∈ L(E1 · · · En ) and following Definition 3, L(E1 · · · En ) ⊂ L(E) and then

300

P. Caron, J.-M. Champarnaud, and L. Mignot

w ∈ L(E). If k = 1, then, according to Definition 9.3, E is (1, k − 1)-nullable, and according to Corollary 1, w ∈ L(E). (P4) Last(E): The proof is similar to (P3) reasoning on last symbols of a word. (P5) Follow(E, x): (⇒) Let x ∈ Follow(E, x). Then ∃k  ∈ 1, n | x ∈ Pos(Ek ). (1) Suppose that k = k  . Then ∃wk = wk · ax · ax · wk ∈ L(Ek ). If w = w1 · · · wk · · · wn with ∀i ∈ 1, n\{k}, wi ∈ L(Ei )\{ε} (this decomposition exists according to Definition 8), we have following Definition 3, w ∈ L(E1,n ) ⊂ L(E), and then w ∈ L(E). (2) Let us suppose k = k  . According to Definition 9.5, x ∈ Last(Ek ), k = n and x ∈ First(Ek ). Thus, ∃wk = wk · ax ∈ L(Ek ) and ∃wk = ax · wk ∈ L(Ek ). Let w = w1 · · · wk · wk · · · wn with ∀i ∈ 1, n \ k, k  , wi ∈ L(Ei ) \ {ε} (this decomposition exists according to Definition 8). (a) Suppose that k  = k + 1. According to Definition 3, w ∈ L(E1 · · · Ek ·Ek+1 · · · En ) ⊂ L(E), and w ∈ L(E). (b) Suppose that k  > k + 1. If x ∈ Follow(E, x), then, we know, according to Definition 9.5 that E is (k +1, k  −1)-nullable, and then according to Corollary 1, w ∈ L(E). (⇐) Suppose that ∃w = w · ax · ax · w ∈ L(E). There exists k  | n > k  ≥ k > 1 such that x ∈ Pos(Ek ). (1) Suppose that k = k  . According to Lemma 1, w is equal to w1 · · · wk · · · wn with ∀i ∈ 1, n, wi ∈ L(Ei ) and wk = wk · ax · ax · wk . Thus, x ∈ Follow(Ek , x) and then x ∈ Follow(E, x). (2) Suppose that k = k  . According to Lemma 1, w = w1 · · · wk · wk · · · wn with ∀i ∈ 1, n, wi ∈ L(Ei ), wk = wk · ax and wk = ax · wk . (a) If k  = k + 1, as x ∈ First(Ek+1 ), we have x ∈ Follow(E, x). (b) If k  > k + 1, according to Proposition 1, there exists a free list S = (i, f )j j∈1,Card(S) such that for all (i, f ) ∈ S, the factor wi · · · wf is ε-maximal, and E is S-nullable. As wk+1 · · · wk −1 is ε-maximal, (k + 1, k  − 1) ∈ S and then E is (k + 1, k  − 1)-nullable. Thus, x ∈ Follow(E, x) following Definition 9.5.

7

Conclusion

Adding multi-tilde operators to the set of regular operators allow us to provide shorter expressions for denoting a given regular language. Given an extended expression, it is always possible to compute an equivalent expression in tilde normal form. Such expressions are compatible with Glushkov functions, and thus, any extended expression can still be turned into an equivalent Glushkov automaton. The same properties have been proved for multi-bar operators [17]. In order to achieve the second step of our programme we have considered expressions that are augmented by both multi-bar and multi-tilde operators and we have made use of the properties of the associated tilde normal form to recover an extended expression from a given Glushkov automaton. This result should be communicated shortly.

Multi-tilde Operators and Their Glushkov Automata

301

References 1. McNaughton, R.F., Yamada, H.: Regular expressions and state graphs for automata. IEEE Transactions on Electronic Computers 9, 39–57 (1960) 2. Glushkov, V.M.: On a synthesis algorithm for abstract automata. Ukr. Matem. Zhurnal 12(2), 147–156 (1960) (in Russian) 3. Brzozowski, J.A., McCluskey, E.J.: Signal flow graph techniques for sequential circuit state diagrams. IEEE Trans. on Electronic Computers EC-12(2) (1963) 4. Hagenah, C., Muscholl, A.: Computing epsilon-free nfa from regular expressions in O(n log2 (n)) time. ITA 34(4), 257–278 (2000) 5. Hromkovic, J., Seibert, S., Wilke, T.: Translating regular expressions into small εfree nondeterministic finite automata. J. Comput. Syst. Sci. 62(4), 565–588 (2001) 6. Brüggemann-Klein, A.: Regular expressions into finite automata. Theoret. Comput. Sci. 120(2), 197–213 (1993) 7. Champarnaud, J.M., Ziadi, D.: From c-continuations to new quadratic algorithms for automata synthesis. Internat. J. Algebra Comput. 11(6), 707–735 (2001) 8. Ilie, L., Yu, S.: Follow automata. Inf. Comput. 186(1), 140–162 (2003) 9. Delgado, M., Morais, J.: Approximation to the smallest regular expression for a given regular language. In: Domaratzki, M., Okhotin, A., Salomaa, K., Yu, S. (eds.) CIAA 2004. LNCS, vol. 3317, pp. 312–314. Springer, Heidelberg (2005) 10. Han, Y.S., Wood, D.: Obtaining shorter regular expressions from finite-state automata. Theor. Comput. Sci. 370(1-3), 110–120 (2007) 11. Ellul, K., Krawetz, B., Shallit, J., Wang, M.: Regular expressions: New results and open problems. Journal of Automata, Languages and Combinatorics 10(4), 407–437 (2005) 12. Ziadi, D.: Regular expression for a language without empty word. Theor. Comput. Sci. 163(1&2), 309–315 (1996) 13. Gelade, W., Neven, F.: Succinctness of the complement and intersection of regular expressions. In: Albers, S., Weil, P. (eds.) STACS. Dagstuhl Seminar Proceedings, vol. 08001, pp. 325–336 (2008) 14. Gruber, H., Holzer, M.: Finite automata, digraph connectivity, and regular expression size. In: Aceto, L., Damgård, I., Goldberg, L.A., Halldórsson, M.M., Ingólfsdóttir, A., Walukiewicz, I. (eds.) ICALP 2008, Part II. LNCS, vol. 5126, pp. 39–50. Springer, Heidelberg (2008) 15. Gruber, H., Holzer, M.: Language operations with regular expressions of polynomial size. In: Câmpeanu, C. (ed.) 10th International Workshop on Descriptional Complexity of Formal Systems (DCFS 2008), Charlottetown, Canada, pp. 182–193 (2008) 16. Caron, P., Ziadi, D.: Characterization of Glushkov automata. Theoret. Comput. Sci. 233(1–2), 75–90 (2000) 17. Caron, P., Champarnaud, J.M., Mignot, L.: A new family of regular operators fitting with the position automaton computation. In: et al. (eds.) International Conference on Current Trends in Theory and Practice of Computer Science (SOF˝ SEM 2009), Spindleruv Mýn, Czech Republic. LNCS (2009) 18. Hopcroft, J.E., Ullman, J.D.: Introduction to Automata Theory, Languages and Computation. Addison-Wesley, Reading (1979) 19. Yu, S.: Regular languages. In: Rozenberg, G., Salomaa, A. (eds.) Handbook of Formal Languages. Word, Language, Grammar, vol. I, pp. 41–110. Springer, Berlin (1997) 20. Conway, J.H.: Regular algebra and finite machines. Chapman and Hall, Boca Raton (1971)

Non-uniform Cellular Automata Gianpiero Cattaneo1 , Alberto Dennunzio1 , Enrico Formenti2, , and Julien Provillard3 1 Universit` a degli Studi di Milano–Bicocca Dipartimento di Informatica, Sistemistica e Comunicazione, Viale Sarca 336, 20126 Milano, Italy {cattang,dennunzio}@disco.unimib.it 2 Universit´e de Nice-Sophia Antipolis, Laboratoire I3S, 2000 Route des Colles, 06903 Sophia Antipolis, France [email protected] 3 Ecole Normale Sup´erieure de Lyon, 46, All´ee d’Italie, 69364 Lyon, France [email protected]

Abstract. In this paper we begin the study the dynamical behavior of non-uniform cellular automata and compare it to the behavior of “classical” cellular automata. In particular we focus on surjectivity and equicontinuity.

1

Introduction and Motivations

Cellular automata (CA) are a well-known formal model for complex systems that is used in many scientific fields [1,2,3]. Uniformity is one of the main characteristics of this model. Indeed, a cellular automaton is made of identical finite automata arranged on a regular lattice. The state of each automaton is updated by a local rule on the basis of the state of the automaton itself and of the one of a fixed set of neighbors. At each time-step, the same (here comes uniformity) local rule is applied to all finite automata in the lattice. For recent results on CA dynamics and an up-to-date bibliography see for instance [4,5,6,7,8,9,10,11,12,13,14,15,16]. In this paper we study a more general setting relaxing the uniformity constraint. Assume to use CA for simulating a physical or natural phenomenon. Relaxing the uniformity constraint can be justified in several situations: Generality. In many phenomena, each individual locally interacts with others but maybe these interactions depend on the individual itself or on its position in the space. 



This work has been supported by the Interlink/MIUR project “Cellular Automata: Topological Properties, Chaos and Associated Formal Languages”, by the ANR Blanc “Projet Sycomore” and by the PRIN/MIUR project “Formal Languages and Automata: Mathematical and Applicative Aspects”. Corresponding author.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 302–313, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Non-uniform Cellular Automata

303

Structural stability. Assume that we are investigating the robustness of a system w.r.t. some specific property P . If some individuals change their “standard” behavior does the system still have property P ? What is the “largest” number of individuals that can change their default behavior so that the system does not change its overall evolution? Reliability. CA are more and more used to perform (fast parallel) computations (see for example [2]). Each cell of the CA is implemented by a simple electronic device (FPGAs for example). Then, how reliable are computations w.r.t. failure of some of these devices? (Here failure is interpreted as a device which behaves differently from its “default” way). Finally, remark that the study of these generalizations has an interest in its own since the new model coincides with the set of continuous functions in Cantor topology.

2

Non-uniform Cellular Automata ν-CA

In the present paper we focus on the one-dimensional case (i.e. the lattice is Z). Remark that most of the following definitions can be easily extended to higher dimensions. Before introducing the formal definition of ν-CA, one should recall the definition of cellular automaton. Let A be a finite set describing the possible states of any cell. A configuration is a snapshot of the states of all cells in the CA, i.e., a function from Z to A. Given a configuration x, we denote by xi ∈ A the state of the cell in position i ∈ Z. For a fixed state a ∈ A, a configuration is a-finite if only a finite number of automata in the CA are in a state different from a. A (one-dimensional) CA is a structure A, r, f , where A is the above introduced finite set of states, also called the alphabet, and f : A2r+1 → A is the local rule whose radius is r. The global rule induced by a CA A, r, f  is the map F : AZ → AZ defined by ∀x ∈ AZ , ∀i ∈ Z, F (x)i = f (xi−r , . . . , xi+r ) .

(1)

This rule describes the global evolution of the CA from the generic configuration x ∈ AZ at time-step t ∈ N to the configuration F (x) at the next time-step t + 1. The configuration set AZ is equipped with the distance d(x, y) = 2−n where n = min{i ≥ 0 : xi = yi or x−i = y−i }. With respect to the topology induced by d, the configuration set is a Cantor space and F is continuous. Hence, (AZ , F ) is a discrete (time) dynamical system. Notation. Given a configuration x ∈ AZ , for any pair i, j ∈ Z, with i ≤ j, we denote by x[i,j] the word xi · · · xj ∈ Aj−i+1 , i.e., the portion of the configuration x inside the interval [i, j] = {k ∈ Z : i ≤ k ≤ j}. A cylinder of block u ∈ Ak and position i ∈ Z is the set [u]i = {x ∈ AZ : x[i,i+k−1] = u}. Cylinders are clopen sets w.r.t. the metric d.

304

G. Cattaneo et al.

The meaning of (1) is that the same local rule f is applied to each site of the CA. Relaxing this last constraint gives us the definition of a ν-CA. More formally one can give the following. Definition 1 (Non-Uniform Cellular Automaton (ν-CA)). A non-uniform Cellular Automaton (ν-CA) is a structure A, {hi , ri }i∈Z  defined by a family of local rules hi : A2ri +1 → A of radius ri all based on the same set of states A. Similarly to CA, one can define the global rule of a ν-CA as the map H : AZ → AZ given by the law ∀x ∈ AZ , ∀i ∈ Z,

H(x)i = hi (xi−ri , . . . , xi+ri ) .

From now on, we identify a ν-CA (resp., CA) with the discrete dynamical system induced by itself or even with its global rule H (resp., F ). It is well known that the Hedlund’s Theorem [17] characterizes CA as the class of continuous functions commuting with the shift map σ : AZ → AZ , where ∀x ∈ AZ , ∀i ∈ Z, σ(x)i = xi+1 . It is possible to give a characterization also of the class of ν-CA since it is straightforward to prove the following. Proposition 1. A function H : AZ → AZ is the global map of a ν-CA iff it is continuous. The previous proposition gives the important information that the pair (AZ , H) is a discrete dynamical system, but in many practical cases this setting is by far too general to be useful. Therefore, we are going to focus our attention only over two special subclasses of ν-CA. Definition 2 (dν-CA). A ν-CA H is a dν-CA if there exist two natural k, r and a rule h : A2r+1 → A such that for all integers i with |i| > k it holds that hi = h. In this case, we say that H has default rule h. Definition 3 (rν-CA). A ν-CA H is a rν-CA if there exists an integer r such that any local rule hi has radius r. In this case, we say that H has radius r. The first class restricts the number of positions at which non-default rules can appear, while the second class restricts the number of different rules but not the number of occurrences nor it imposes the presence of a default rule. Some easy examples follow. Example 1. Consider the ν-CA H (1) : AZ → AZ defined as ∀x ∈ AZ , H (1) (x)i = 1 if i = 0; 0 otherwise. Remark that H (1) is a dν-CA which cannot be a CA since it does not commute with σ. So the class of ν-CA is larger than the original class of all CA. Example 2. Consider the ν-CA H (2) : AZ → AZ defined as ∀x ∈ AZ , H (2) (x)i = 1 if i is even; 0 otherwise. Remark that H (2) is a rν-CA but not a dν-CA. Example 3. Consider the ν-CA H (3) : AZ → AZ defined as ∀x ∈ AZ , H (3) (x)i = x0 . Remark that H (3) is a ν-CA but not a rν-CA. Focusing the study on dν-CA and rν-CA is not a great loss in generality since (at some extent) each ν-CA can be viewed as the limit of a sequence of dν-CA.

Non-uniform Cellular Automata

305

Proposition 2. CA  dν-CA  rν-CA  ν-CA, where CA is the set of all CA. Proof. The inclusions ⊆ easily follow from the definitions. For the strict inclusions refer to Examples 1 to 3.  Similarly to what happens for CA one can prove the following. Proposition 3. For every rν-CA H on the alphabet A there exists a radius 1 rν-CA H  and a bijective continuous mapping φ such that H ◦ φ = φ ◦ H  . That is, H is topologically conjugated to H  . Proof. Let H be a rν-CA. If H has radius r = 1 then this result is trivially true using the identity as a conjugacy map. If r > 1, let B = Ar and define φ : AZ → B Z as ∀i ∈ Z, φ(x)i = x[ir,(i+1)r) . Then, it is not difficult to see that the rν-CA (B Z , H  ) of radius 1 defined as ∀x ∈ AZ , ∀i ∈ Z, H  (x)i = hi (xi−1 , xi , xi+1 ) is topologically conjugated to H via φ, where ∀u, v, w ∈ B, ∀i ∈  Z, ∀j ∈ {0, . . . , r − 1}, (hi (u, v, w))j = hir+j (u[j,r) vw[0,j] ). Finally, the following result shows that every rν-CA is a subsystem of a suitable CA. Therefore, the study of rν-CA dynamics might reveal new properties for CA and vice-versa. Theorem 1. Any rν-CA H : AZ → AZ of radius r is a subsystem of a CA, i.e., there exist a CA F : B Z → B Z on a suitable alphabet B and a continuous injection φ : AZ → B Z such that φ ◦ H = F ◦ φ. Proof. Consider a rν-CA H : AZ → AZ of radius r. Remark that there are only 2r+1 distinct functions hi : A2r+1 → A. Take a numbering (fj )1≤j≤n n = |A||A| of these functions and let B = A × {1, . . . , n}. Define the mapping φ : AZ → B Z such that ∀x ∈ AZ , ∀i ∈ Z, φ(x)i = (xi , k), where k is the integer for which H(x)i = fk (xi−r , . . . , xi+r ). Clearly, φ is injective and continuous. Now, define a CA F : B Z → B Z using the local rule f : B 2r+1 → B such that f ((x−r , k−r ), . . . , (x0 , k0 ), . . . , (xr , kr )) = (fk0 (x−r , . . . , xr ), k0 ) . It is not difficult to see that φ ◦ H = F ◦ φ.

3



CA vs. ν-CA

In this section, we investigate some differences in dynamical behavior between CA and ν-CA. As we are going to see, many characteristics which are really specific to the whole class of CA are lost in the larger class of ν-CA. This will be explored by showing via counter-examples that these properties are not satisfied by the whole class of ν-CA. First of all, let us recall that given a ν-CA H, a configuration x ∈ AZ is an ultimately periodic point of H if there exist p, q ∈ N such that H p+q (x) = H q (x). If q = 0, then x is periodic, i.e., H p (x) = x. The minimum p for which H p (x) = x

306

G. Cattaneo et al.

holds is called period of x. A ν-CA is surjective (resp. injective) if its global rule is surjective (resp. injective). It is well known that in the case of CA the collection of all ultimately periodic configurations is dense in the configurations space AZ . This property is not true in the general case of ν-CA. We will show this result making reference to the following interesting example of ν-CA. Example 4. Let A = {0, 1} and define the following dν-CA H (4) : AZ → AZ as  xi if i = 0 ∀x ∈ AZ , ∀i ∈ Z, H (4) (x)i = xi−1 otherwise . The first no–go result is relative to the above example. Proposition 4. The set of ultimately periodic points of H (4) is not dense. Proof. Let H = H (4) . Denote by P and U the sets of periodic and ultimately periodic points, respectively. Let E = {x ∈ AZ : ∀i ∈ N, xi = x0 }. Take x ∈ P with H p (x) = x. Remark that the set Bx = {i ∈ N : xi = x0 } is empty. Indeed, by contradiction, assume that B = ∅ and let m = min B. It is easy to check that ∀y ∈ AZ , ∀i ∈ N, H i (y)[0,i] = y0 i+1 , hence xm = H pm (x)m = x0 , contradiction. Thus x ∈ E and P ⊆ E. Let y ∈ H −1 (E). We show that By = ∅. By contradiction, let n = min By . / E. Contradiction, then y ∈ E Since H(y)n+1 = yn = y0 = H(y)0 , then H(y) ∈  −1 −n −n and H (E) ⊆ E. So ∀n ∈ N, H (E) ⊆ E. Moreover, U = (P ) ⊆ n∈N H  −n H (E) ⊆ E and E is not dense.  n∈N The following proposition proves that H (4) is not surjective, despite it is based on two local rules each of which generates a surjective CA (namely, the identity CA and the shift CA). Moreover, unlike the CA case (see [17]), H (4) has no configuration with an infinite number of pre-images although it is not surjective. Proposition 5. The dν-CA H (4) is not surjective and any configuration has either 0 or 2 pre-images. Proof. Since ∀x ∈ AZ , H (4) (x)0 = H (4) (x)1 , configurations in the set B = {x ∈ AZ : x0 = x1 } have no pre-image. Then any x ∈ AZ \ B has 2 pre-images y and z such that ∀i ∈ / {−1, 0}, yi = zi = xi+1 , y0 = z0 = x0 , y−1 = 0; z−1 = 1.  In order to explore some other no-go results, we introduce an other example. Example 5. Let A = {0, 1} and define a ν-CA H (5) : AZ → AZ by  0 if i = 0 Z (5) ∀x ∈ A , ∀i ∈ Z, H (x)i = xi−1 ⊕ xi+1 otherwise , where ⊕ is the xor operator. The following results show that in the case of ν-CA, the Moore-Myhill theorem on CA [18,19] is no more true.

Non-uniform Cellular Automata

307

Proposition 6. The ν-CA H (5) is injective on the finite 0-configurations but it is not surjective. Proof. It is evident that H (5) is not surjective. Let x, y be two finite configurations such that H (5) (x) = H (5) (y). By contradiction, assume that xi = yi , for some i ∈ Z. Without loss of generality, assume that i ∈ N. Since xi ⊕ xi+2 = H (5) (x)i+1 = H (5) (y)i+1 = yi ⊕ yi+2 , it holds that xi+2 = yi+2 and, by induction, ∀j ∈ N, xi+2j = yi+2j . We conclude that ∀j ∈ N, xi+2j = 1 or yi+2j = 1 contradicting the assumption that x and y are finite.  A ν-CA H is positively expansive if there exists  > 0 such for any pair of distinct x, y ∈ AZ , d(H n (x), H n (y)) >  for some n ∈ N. A ν-CA H is transitive if for any distinct pair of non-empty open sets U, V ⊂ AZ , there exists n ∈ N such that H n (U )∩V = ∅. Both of these properties are considered as standard indicators of chaotic behavior. We will show now that, unlike the CA case, positively expansive ν-CA are not necessarily transitive nor surjective. Proposition 7. The ν-CA H (5) is positively expansive but it is neither transitive nor surjective. Proof. Let H = H (5) . By Proposition 6, H is not surjective and hence it is not transitive. Let x and y be two distinct configurations. Without loss of generality, one can assume that there exists k = min{i ∈ N, xi = yi }. If k ≤ 1, we have d(H 0 (x), H 0 (y)) ≥ 12 . Otherwise, H(x)k−1 = xk−2 ⊕ xk = yk−2 ⊕ yk = H(y)k−1 and H(x)[0,k−2] = H(y)[0,k−2] . By induction on k ∈ N, it is easy to see that H k−1 (x)1 = H k−1 (y)1 . Hence d(H k−1 (x), H k−1 (y)) ≥ 12 . Thus H is positively expansive with expansivity constant 12 .  Example 6. Let A = {0, 1} and define the ν-CA H (6) ⎧ ⎪ ⎨xi+1 Z (6) ∀x ∈ A , ∀i ∈ Z, H (x)i = x0 ⎪ ⎩ xi−1

: AZ → AZ as follows if i < 0 if i = 0 otherwise.

Recall that for CA, the compactness of AZ and the uniformity of the local rule allow one to prove that injective CA are surjective. The following result shows that this does not hold in the case of ν-CA. Proposition 8. The ν-CA H (6) is injective but not surjective. Proof. Let H = H (6) . Concerning non-surjectivity, just remark that only configurations x such that x−1 = x0 = x1 have a pre-image. Let x, y ∈ AZ with H(x) = H(y). Then, we have ∀i > 0, xi−1 = yi−1 and ∀i < 0, xi+1 = yi+1 . So x = y and H is injective. 

4

Surjectivity

In the context of (1D) CA, the notion of De Bruijn graph is very handy to find fast decision algorithms for surjectivity, injectivity and openness. Here, we extend

308

G. Cattaneo et al.

this notion to work with dν-CA and find decision algorithm for surjectivity. We stress that surjectivity is undecidable for two (or higher) dimensional dν-CA, since surjectivity is undecidable for 2D CA [20]. Definition 4. Consider a dν-CA H of radius r and let f be its default rule. Let k ∈ N be the largest integer such that hk = f or h−k = f . The De Bruijn graph of H is the pair (V, E) where V = A2r ×{−k −1, . . . , k +1} and E is the set of pairs ((a, i), (b, j)) with label in A × {0, 1} and such that ∀i ∈ {0, . . . , 2r − 1}, ai = bi+1 and one of the following condition is verified a) i = j = −k − 1; in this case the label is (f (a0 b), 0) b) i + 1 = j; in this case the label is (hk (a0 b), 0) c) i = j = k + 1; in this case the label is (f (a0 b), 1) By this graph, a configuration can be seen as a bi-infinite path on vertexes which passes once from a vertex whose second component is in [−k + 1, k − 1] and infinite times from other vertices. The second component of vertices allows to single out the positions of local rules different from the default one. The image of a configuration is the sequence of first components of edge labels. Theorem 2. Surjectivity is decidable for dν-CA. Proof. We show that a dν-CA H is surjective iff its De Bruijn graph G recognizes the language (A × {0})∗ (A × {1})∗ when it is considered as the graph of a finite state automaton. Denote by (a1 , a2 ) any word of (A × {0, 1})∗. Let k be as in Definition 4. Assume that H is surjective and take u ∈ (A × {0})∗ (A × {1})∗ . Let n be the number of 0’s appearing in u (in the second component). We have three cases: 1. If n = 0 then there exists v ∈ A∗ such that f (v) = u and we can construct u by the sequence of vertices (v[0,2r) , k + 1), . . . , (v[|v|−2r,|v|) , k + 1). 2. If 0 < n < |u| then there exists v ∈ A∗ such that hk+1−n (v) = u. We can construct u by the sequence of vertices (v[0,2r) , u0 ), . . . , (v[|v|−2r,|v|) , u|v|−2r−1) where ⎧ −k − 1 if k + 1 − n + j < k ⎨ k+1 if k + 1 − n + j > k uj = ⎩ k + 1 − n + j otherwise 3. If n = |u| then there exists v ∈ A∗ such that f (v) = u and we can construct u by the sequence of vertices (v[0,2r) , −k − 1), . . . , (v[|v|−2r,|v|) , −k − 1). For the opposite implication, assume that G recognizes (A × {0})∗ (A × {1})∗ . n+k+1 n−k Take y ∈ AZ and let n > k. Since G recognizes (y[−n,n] 1 ), there exists  ,0 Z ∗ v ∈ A such that H(v)[−n,n] = y[−n,n] . Set Xn = x ∈ A , x[n,n] = y[−n,n] . For any n ∈ N, Xn is non-empty and compact. Moreover, Xn+1 ⊆ Xn . Therefore, X = n∈N Xn = ∅ and H(X) = {y}. Hence, H is surjective. 

Non-uniform Cellular Automata

5 5.1

309

More on Dynamical Properties Equicontinuity

Let H be a ν-CA. A configuration x ∈ AZ is an equicontinuity point for H if ∀ε > 0 there exists δ > 0 such that for all y ∈ AZ , d(y, x) < δ implies that ∀n ∈ N, d(H n (y), H n (x)) < ε. A ν-CA is said to be equicontinuous if the set E of all its equicontinuous points is the whole AZ , while it is said to be almost equicontinuous if E is residual (i.e., E can be obtained by a countable intersection of dense open subsets). A word u ∈ Ak is s-blocking (s ≤ k) for a CA F if there exists an offset j ∈ [0, k − s] such that for any x, y ∈ [u]0 and urka proved that a CA is any n ∈ N, F n (x)[j,j+s−1] = F n (y)[j,j+s−1] . In [21], K˚ almost equicontinuous iff it is non-sensitive iff it admits a blocking word. We now introduce a class of ν-CA which will be useful in the sequel. It is an intermediate class between dν-CA and rν-CA. Definition 5 (n-compatible rν-CA). A rν-CA H is n-compatible with a local rule f if for any k ∈ N, there exist two integers k1 > k and k2 < −k such that ∀i ∈ [k1 , k1 + n) ∪ [k2 , k2 + n), hi = f . In other words, a ν-CA is n-compatible with f if, arbitrarily far from the center of the lattice, there are intervals of length n in which the local rule f is applied. The notion of blocking word and the related results cannot be directly restated in the context of ν-CA because some words are blocking just thanks to the uniformity of CA. To overcome this problem we introduce the following notion. Definition 6 (Strongly blocking word). A word u ∈ A∗ is strongly sblocking for a CA F of local rule f if there exists an offset p ∈ [0, |u| − s] such that for any ν-CA H with ∀i ∈ {0, . . . , |u| − 1}, hi = f it holds that ∀x, y ∈ [u]0 , ∀n ≥ 0,

H n (x)[p,p+s) = H n (y)[p,p+s) .

Roughly speaking, a word is strongly blocking if it is blocking whatever be the perturbations involving the rules in its neighborhood. The following extends Proposition 5.12 in [22] to strongly r-blocking words. Proposition 9. Any r radius CA F is equicontinuous iff there exists k > 0 such that any word u ∈ Ak is strongly r-blocking for F . Proof. If any word is strongly blocking then F is obviously equicontinuous. For the opposite implication, by [22, Prop. 5.12], there exist p > 0 and q ∈ N such that F q+p = F q . As a consequence, we have that ∀u ∈ A∗ , |u| > 2(q + p)r ⇒ f p+q (u) = f q (u)[pr,|u|−(2q+p)r) . Let H be a ν-CA such that hi = f for each i ∈ {0, . . . , (2p + 2q + 1)r − 1}. For any x ∈ AZ and i ≥ 0, consider the following words: s(i) = H i (x)[0,qr) , t(i) = H i (x)[qr,(q+p)r) , u(i) = H i (x)[(q+p)r,(q+p+1)r) , v (i) = H i (x)[(q+p+1)r,(q+2p+1)r) , w(i) = H i (x)[(q+2p+1)r,(2q+2p+1)r) . For all i ∈ 0, . . . , q + p, u(i) is fully determined by s(0) t(0) u(0) v (0) w(0) = x[0,(2q+2p+1)r) . Moreover, for any natural i, we have u(i+q+p) = f q+p (s(i) t(i) u(i) v (i) w(i) ) =

310

G. Cattaneo et al.

f q (s(i) t(i) u(i) v (i) w(i) )[pr,(p+1)r) = (t(i+q) u(i+q) v (i+q) )[pr,(p+1)r) = u(i+q) . Summarizing, for all i ∈ N, u(i) is determined by the word x[0,(2q+2p+1)r) which is then strongly r-blocking. Since x had been chosen arbitrarily, we have the thesis.  Theorem 3. Let F be a CA with local rule f admitting a strongly r-blocking word u. Let H be a rν-CA of radius r. If H is |u|-compatible with f then H is almost equicontinuous. Proof. Let p and n be the offset and the length of u, respectively. For any k ∈ N, consider the set Tu,k of configurations x ∈ AZ having the following property P: there exist l > k and m < −k such that x[l,l+n) = x[m,m+n) = u and ∀i ∈ [l, l + n) ∪ [m, m + n) hi = f . Remark that Tu,k is open, being a union of

cylinders. Clearly, each Tu,k is dense, thus the set Tu = k≥n Tu,k is residual. We claim that any configuration in Tu is an equicontinuity point. Indeed, choose arbitrarily x ∈ Tu . Set  = 2−k , where k ∈ N is such that x ∈ Tu,k . Then, there exist k1 > k and k2 < −k − n satisfying P. Fix δ = min{2−(k1 +n) , 2−k2 } and let y ∈ AZ be such that d(x, y) < δ. Then y[k2 ,k1 +|u|) = x[k2 ,k1 +|u|) . Since u is rblocking, ∀t ∈ N, H t (x) and H t (y) are equal inside the intervals [k1 +p, k1 +p+r] and [k2 + p, k2 + p + r], then d(H t (x), H t (y)) < .  In a similar manner one can prove the following. Theorem 4. Let F be an equicontinuous CA of local rule f . Let k ∈ N be as in Proposition 9. Any rν-CA k-compatible with f is equicontinuous. 5.2

Sensitivity to the Initial Conditions

Recall that a CA F is sensitive to the initial conditions (or simply sensitive) if there exists a constant ε > 0 such that for any configuration x ∈ AZ and any δ > 0 there is a configuration y ∈ AZ such that d(y, x) < δ and d(F n (y), F n (x)) ≥ ε for some n ∈ N. Example 7. Let A = {0, 1, 2} and consider the CA whose local rule f : A3 → A is defined as follows: ∀x, y ∈ A, f (x, 0, y) = 1 if x = 1 or y = 1, 0 otherwise; f (x, 1, y) = 2 if x = 2 or y = 2, 0 otherwise; f (x, 2, y) = 0 if x = 1 or y = 1, 2 otherwise. Proposition 10. The CA defined in Example 7 is almost equicontinuous. Proof. Just remark that the number of 0s inside the word 20i 2 is non-decreasing. Thus 202 is a 1-blocking word.  The following example defines a ν-CA which is sensitive to the initial conditions although its default rule give rise to an almost equicontinuous CA. Example 8. Consider the dν-CA H (8) : AZ → AZ defined as follows  1 if i = 0 Z (8) ∀x ∈ A , ∀i ∈ Z, H (x)i = f (xi−1 , xi , xi+1 ) otherwise , where f and A are as in Example 7.

Non-uniform Cellular Automata

311

Remark that positive and negative cells do not interact each other under the action of H (8) . Therefore, in order to study the behavior of H (8) , it is sufficient to consider the action of H (8) on AN . Lemma 1. For any u ∈ A∗ , ∃n0 ∈ N such that ∀n > n0 , (H (8) )n (u0∞ )1 = 1. Lemma 2. ∀u ∈ A∗ , ∀n0 ≥ 0, ∃n > n0 , (H (8) )n (u2∞ )1 = 2. Proposition 11. The dν-CA H (8) is sensitive. Proof. Let H = H (8) and F be the set of all a-finite configurations for a ∈ {0, 2}. By a theorem of Knudesen [23], we can prove the statement w.r.t. F . Then, for any u ∈ A∗ . Build x = u0∞ and y = u2∞ . By Lemma 1 and 2, there exists n such that 1 = H n (x)1 = H n (y)1 = 2. And hence H is sensitive with sensitivity constant  = 1/2.  The following example shows that default rules individually defining almost equicontinuous CA can also constitute ν-CA that have a completely different behavior from the one in Example 8. Example 9. Let A = {0, 1, 2} and define the local rule f : A3 → A as: ∀x, y, z ∈ A, f (x, y, z) = 2 if x = 2 or y = 2 or z = 2, z otherwise. The CA F of local rule f is almost equicontinuous since 2 is a blocking word. The restriction of F to {0, 1}Z gives the shift map which is sensitive. Thus F is not equicontinuous. Define now the following dν-CA H (9) :  2 if i = 0 ∀x ∈ AZ , ∀i ∈ Z, H (9) (x)i = f (xi−1 , xi , xi+1 ) otherwise . Proposition 12. The dν-CA H (9) is equicontinuous. Proof. Let n ∈ N, x, y ∈ AZ be such that x[−2n,2n] = y[−2n,2n] . Since H is of radius 1, ∀k ≤ n, H k (x)[−n,n] = H k (y)[−n,n] and ∀k > n, H k (x)[−n,n] = 22n+1 = H k (y)[−n,n] . So, H is equicontinuous.  5.3

Expansivity and Permutivity

Recall that a rule f : A2r+1 is leftmost (resp., rightmost) permutive if ∀u ∈ A2r , ∀b ∈ A, ∃!a ∈ A, f (au) = b (resp., f (ua) = b). This definition can be easily extended to ν-CA. Indeed, we say that a rν-CA is leftmost (resp. rightmost) permutive if all hi are leftmost (resp. rightmost) permutive. A ν-CA is permutive if it is leftmost or rightmost permutive. In a very similar way to CA, given a ν-CA H and two integers a, b ∈ N with a < b, the column subshift (Σ[a,b] , σ) of H is defined as follows Σ[a,b] = {y ∈ N

(Ab−a+1 ) : ∃x ∈ AZ , ∀i ∈ N, yi = H i (x)[a,b] }. Consider the map I[a,b] : AZ → Σ[a,b] defined as ∀x ∈ AZ , ∀i ∈ N, I[a,b] (x)i = H i (x)[a,b] . It is not difficult to see that I is continuous and surjective. Moreover H ◦ I[a,b] = I[a,b] ◦ σ. Thus (ΣI , σ) is a factor of the ν-CA (AZ , H) and we can lift some properties from (Σ[a,b] , σ) to (AZ , H). The following result tells that something stronger happens in the special case of leftmost and rightmost permutive rν-CA.

312

G. Cattaneo et al.

Theorem 5. Any leftmost and rightmost permutive rν-CA of radius r is conjugated to the full shift ((A2r )N , σ). Proof. Just remark that the map I[1,2r] : AZ → (A2r )N is bijective.



The requirements of the previous theorem are very strong. Indeed, there exist ν-CA which are topologically conjugated to a full shift but that are not permutive. As an example, consider the ν-CA H defined as follows  xi−1 if i ≤ 0 ∀x ∈ AZ , ∀i ∈ Z, H(x)i = xi+1 otherwise . Then, Σ[0,1] = (A2 )N et I[0,1] is injective.

6

Conclusions

In this paper we started exploring the dynamical behavior of ν-CA. Many specific properties for CA are no longer true for ν-CA. However, under certain conditions, some stability forms turned out to be quite robust when altering a CA to obtain a ν-CA. Despite of the many no-go results proved in this paper, we strongly believe that ν-CA can be useful for many practical applications and hence deserve further studies.

References 1. Farina, F., Dennunzio, A.: A predator-prey ca with parasitic interactions and environmentals effects. Fundamenta Informaticae 83, 337–353 (2008) 2. Chaudhuri, P., Chowdhury, D., Nandi, S., Chattopadhyay, S.: Additive Cellular Automata Theory and Applications, vol. 1. IEEE Press, Los Alamitos (1997) 3. Chopard, B.: Modelling physical systems by cellular automata. In: Rozenberg, G., et al. (eds.) Handbook of Natural Computing: Theory, Experiments, and Applications. Springer, Heidelberg (to appear, 2009) 4. Formenti, E., K˚ urka, P.: Dynamics of cellular automata in non-compact spaces. In: Meyers, B. (ed.) Mathematical basis of cellular automata. Encyclopedia of Complexity and System Science. Springer, Heidelberg (2008) 5. K˚ urka, P.: Topological dynamics of one-dimensional cellular automata. In: Meyers, B. (ed.) Mathematical basis of cellular automata. Encyclopedia of Complexity and System Science. Springer, Heidelberg (2008) 6. Cervelle, J., Dennunzio, A., Formenti, E.: Chaotic behavior of cellular automata. In: Meyers, B. (ed.) Mathematical basis of cellular automata. Encyclopedia of Complexity and System Science. Springer, Heidelberg (2008) 7. Kari, J.: Tiling problem and undecidability in cellular automata. In: Meyers, B. (ed.) Mathematical basis of cellular automata. Encyclopedia of Complexity and System Science. Springer, Heidelberg (2008) 8. Di Lena, P., Margara, L.: Undecidable properties of limit set dynamics of cellular automata. In: 26th Symposium on Theoretical Aspects of Computer Science (STACS 2009). LNCS. Springer, Heidelberg (to appear, 2009)

Non-uniform Cellular Automata

313

9. Di Lena, P., Margara, L.: Computational complexity of dynamical systems: the case of cellular automata. Information and Computation 206, 1104–1116 (2008) 10. Dennunzio, A., Formenti, E.: Decidable properties of 2D cellular automata. In: Ito, M., Toyama, M. (eds.) DLT 2008. LNCS, vol. 5257, pp. 264–275. Springer, Heidelberg (2008) 11. Dennunzio, A., Formenti, E., K˚ urka, P.: Cellular automata dynamical systems. In: Rozenberg, G., et al. (eds.) Handbook of Natural Computing: Theory, Experiments, and Applications. Springer, Heidelberg (to appear, 2009) 12. Dennunzio, A., Formenti, E.: 2D cellular automata: new constructions and decidable properties (submitted, 2009) 13. Acerbi, L., Dennunzio, A., Formenti, E.: Conservation of some dynamcal properties for operations on cellular automata. Theoretical Computer Science (to appear, 2009) 14. Dennunzio, A., Di Lena, P., Formenti, E., Margara, L.: On the directional dynamics of additive cellular automata. Theoretical Computer Science (to appear, 2009) 15. Dennunzio, A., Masson, B., Guillon, P.: Sand automata as cellular automata (submitted, 2009) 16. Dennunzio, A., Guillon, P., Masson, B.: Stable dynamics of sand automata. In: Fifth IFIP Confercence on Theoretical Computer Science (TCS 2008). IFIP, vol. 273, pp. 157–179. Springer, Heidelberg (2008) 17. Hedlund, G.A.: Endomorphisms and automorphisms of the shift dynamical system. Mathematical System Theory 3, 320–375 (1969) 18. Moore, E.F.: Machine models of self-reproduction. In: Proceedings of Symposia in Applied Mathematics, vol. 14, pp. 13–33 (1962) 19. Myhill, J.: The converse to Moore’s garden-of-eden theorem. Proceedings of the American Mathematical Society 14, 685–686 (1963) 20. Kari, J.: Reversibility and surjectivity problems of cellular automata. Journal of Computer and System Sciences 48, 149–182 (1994) 21. K˚ urka, P.: Languages, equicontinuity and attractors in cellular automata. Ergodic Theory & Dynamical Systems 17, 417–433 (1997) 22. K˚ urka, P.: Topological and Symbolic Dynamics. Cours Sp´ecialis´es, vol. 11. Soci´et´e Math´ematique de France (2004) 23. Knudsen, C.: Chaos without nonperiodicity. American Mathematical Monthly 101, 563–565 (1994)

A Cryptosystem Based on the Composition of Reversible Cellular Automata Adam Clarridge and Kai Salomaa Queen’s University, Kingston, Canada {adam,ksalomaa}@cs.queensu.ca

Abstract. We present conditions which guarantee that a composition of marker cellular automata has the same neighbourhood as each of the individual components. We show that, under certain technical assumptions, a marker cellular automaton has a unique inverse with a given neighbourhood. We use these results to develop a working key generation algorithm for a public-key cryptosystem based on reversible cellular automata originally conceived by Kari. We conclude with a discussion on security and practical considerations for the cryptosystem and give several ideas for future work.

1

Introduction

Cryptography has been a part of our everyday lives for some time now. Most widely-used public-key encryption algorithms rely on advanced number theoretic results to achieve a high level of security, such as RSA, whose security is believed to rely on the hardness of the integer factorization problem. These systems tend to have relatively slow implementations [1], and since we will always want more efficient and secure encryption algorithms, it makes sense to consider alternate techniques. Cellular automata (CA) as a medium for encryption is an attractive idea in theory because most CA can be implemented on very fast hardware [2,3,4], hence a CA-based scheme may have the potential to encrypt and decrypt messages faster than existing techniques. Most investigations into CA-based cryptosystems have been aimed at traditional secret-key systems [5,6,7,8,9,10]. There appear to be very few CA-based public-key cryptosystems in the literature; one is the Finite Automata PublicKey Cryptosystem, or Tao-Chen cryptosystem [1], although it uses nonhomogeneous CA. Kari’s paper [11] outlines an idea for a public-key cryptosystem based on reversible cellular automata, and poses the question of how to implement the key generation algorithm. We now review this paper in some detail, as it is the main reference for our work. The general objective of a public-key cryptosystem based on reversible cellular automata (RCA) is to design an RCA that is very hard to invert without some secret knowledge. That way, the RCA can be published and its inverse can be kept as the private key. Kari emphasizes the importance that the RCA be at least two-dimensional, since there exist algorithms to invert any one-dimensional RCA [12], and also because of the following theorem. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 314–325, 2009. c Springer-Verlag Berlin Heidelberg 2009 

A Cryptosystem Based on the Composition of Reversible Cellular Automata

315

Theorem 1. [13] It is undecidable if a given two-dimensional CA is reversible. This is true even when restricted to CA using the von Neumann neighbourhood. This theorem provides a sound theoretical basis for the security of Kari’s publickey cryptosystem [11]. The basic idea outlined in the paper was to compose together several simple and reversible ’marker’ CA (which we define in Section 2) in order to form a more complex cellular automaton C = Cn ◦ Cn−1 ◦ · · · ◦ C1 , with inverse C −1 = C1 −1 ◦ C2 −1 ◦ · · · ◦ Cn −1 . Encryption occurs by encoding the message as the initial configuration of the CA, then evolving the composed CA for some k generations to obtain the ciphertext. The inverse automaton does not need to be computed explicitly; one need only apply each component of the composition in succession. The inverse is then applied for k iterations to decrypt the ciphertext. The composition Cn ◦Cn−1 ◦· · ·◦C1 is the public key, and each of the inverse automata of the composition (C1 −1 , C2 −1 , . . . , Cn −1 ) are kept as the private key. A well-constructed public key should be very hard to invert without knowledge of the components C1 , C2 , . . . , Cn because the neighbourhood size of the inverse automaton would be quite large. Kari’s paper [11] includes an example of a marker RCA composition with a 2-dimensional neighbourhood of 4 cells, and whose inverse has a 2-dimensional neighbourhood of 9 cells. The composition is made up of 5 very simple reversible marker CA. This is of course just an illustrative example, and Kari points out that longer and more complex (more states and a less restricted form) compositions would be needed in order to ensure security against brute force attacks. However, a public key with s states and neighbourhood size n requires sn entries in its local rule table, so it is essential to try to keep n small so that the public key can be stored in reasonably sized memory. The main issue preventing the practical implementation of Kari’s cryptosystem is the question of how to choose (or randomly generate) reversible marker CA such that the neighbourhood size of the composition remains small. In this paper, we give one possible answer to this question and investigate the resulting working cryptosystem. We will state some preliminary assumptions and definitions before discussing our results concerning the composition of a class of marker CA in Sections 2 and 3. We give an algorithm1 for generating public and private keys in Section 4, and discuss practical implementation issues, security considerations, and ideas for future research in Section 5.

2

Preliminaries

In this paper we assume that in a cellular array containing M1 M2 · · · Md cells, where Mi is the number of cells of each dimension for i = 1, . . . , k, the neighbours of cells near the edge of the cellular array are determined by adding the 1

Email the first author for a working software prototype.

316

A. Clarridge and K. Salomaa

component indices cyclically (modulo Mi ). This is simply the toroidal boundary condition. The term ’neighbourhood’ in this paper refers to either the pattern of cells around a cell, or the states themselves in the pattern, depending on the context. A ’marker’ CA is defined by a permutation φ of the state set, and a finite collection of patterns P1 , P2 , . . . , Pk around the origin. For each cell c, the local rule of the marker CA checks if any of the patterns P1 , P2 , . . . , Pk is present as the neighbourhood of c. If so, the permutation φ is applied to c’s state, and if not, then c’s state does not change. Marker CA are also known as ’marker automorphisms of the one-sided d-shift’ [14] in the dynamical systems literature. We define a ’fixed-domain’ marker cellular automaton (or FDM CA) to be a five-tuple (d,S,N ,A,f ) with dimension d, state set S, neighbourhood vector ¯2, . . . , n ¯ k ), n ¯ i ∈ Zd for i = 1, 2, . . . , k, acting set A ⊆ S k with entries N = (¯ n1 , n corresponding to the positions defined by N , and a function f : S → S. The local rule of an FDM CA acts on a cell c (in state s) in the following simple way: if the neighbours of c are in a state configuration corresponding to an element of A, then the state of c on the next generation is f (s). Otherwise, the state of c does not change. An FDM CA is just a special type of marker CA where all of the patterns are mappings from N to S, hence the term ’fixed-domain’. Note that, conversely, an arbitrary marker CA can be represented as an FDM CA by choosing N to be sufficiently large. In this paper, we use the terms ‘invertible’ and ‘reversible’ interchangeably when referring to cellular automata. Also we define compositions of cellular automata in the following way: for any two cellular automata C1 and C2 acting on the same cellular grid, one generation of the CA C2 ◦ C1 refers to the application of one generation of C1 followed by one generation of C2 .

3 3.1

Theoretical Results Neighbourhood Size of Compositions

As we have noted above, for implementing a public-key cryptosystem based on compositions of RCAs, a desirable property is that the composition should have a small neighbourhood size. After defining some terms, we give necessary and sufficient conditions that characterize the effect on neighbourhood size of composing an FDM CA with an arbitrary CA. Let B be an arbitrary cellular automaton with state set S, neighbourhood n1 , n ¯2, . . . , n ¯ k ), n ¯ i ∈ Zd , d ≥ 1, and local transition function hB : S k → S NB = (¯ (hB maps the neighbourhood of a cell to its next state). Denote the set of all possible configurations of the neighbourhood NB = (¯ n1 , n ¯2, . . . , n ¯ k ) of a cell c by SNB (c) = {(sn¯ 1 , sn¯ 2 , . . . , sn¯ k ) | sn¯ i ∈ S for i = 1, . . . , k}, ¯ i. where each sn¯ i refers to the state of the cell in position n The neighbourhood of the neighbourhood of a cell c contains any cell that is a neighbour to one of c’s neighbours. Let us refer to this set as the second order

A Cryptosystem Based on the Composition of Reversible Cellular Automata

317

neighbourhood of c. We will assume without loss of generality that each cell is a neighbour to itself, so each cell in the neighbourhood of c belongs to its second order neighbourhood as well. Denote the collection of all second order neighbourhoods of a cell c with neighbourhood s = (sn¯ 1 , sn¯ 2 , . . . , sn¯ k ) ∈ SNB (c) by ⎫ ⎧⎡ ⎤ tn¯ 1 +¯n1 tn¯ 1 +¯n2 . . . tn¯ 1 +¯nk ⎪ ⎪ ⎪ ⎪ ⎪ ⎪⎢ ⎬ ⎥ ⎨ t t . . . t n ¯ +¯ n n ¯ +¯ n n ¯ +¯ n 2 1 2 2 2 k ⎥ ⎢ k×k ¯ NB (s) = ⎢ . ∈ S S ∀¯ n ∈ N , t = s ⎥ .. B n ¯ n ¯ ⎪ ⎪ ⎦ . ⎪ ⎪⎣ ⎪ ⎪ ⎭ ⎩ tn¯ k +¯n1 tn¯ k +¯n2 . . . tn¯ k +¯nk ¯ NB (s) are the neighbourhoods of each of the cells The rows of each matrix in S in s. The states in positions n ¯1, n ¯2, . . . , n ¯ k are fixed (they are the states of s), while the rest of the second order neighbourhood is arbitrary. The automaton B’s neighbourhood state changes for a cell c with neighbour¯B : S ¯ NB (s) → SNB (c) which maps a hood s can be described by a function h second order neighbourhood to the next neighbourhood of c. The second order neighbourhood contains all the information needed in order to determine the next neighbourhood of c. For the neighbourhood s ∈ SNB (c) we denote the set of all possible next neighbourhoods by ¯ B (¯r) | ¯r ∈ S ¯ NB (s)}. next neighbourhoodB (s) = {h Now we can state conditions which characterize change in neighbourhood size due to composition. Proposition 1. Let B be an arbitrary CA with dimension d, state set S, neighbourhood NB , and local state transition function hB . Let D be an FDM CA (d,S,NB ,AD ,fD ). The composition D ◦ B has neighbourhood equal to NB if and only if for all s ∈ SNB (c), fD (hB (s)) = hB (s) ⇒

next neighbourhoodB (s) ⊆ AD or next neighbourhoodB (s) ∩ AD = ∅

(1)

Proof. Suppose that condition (1) holds. We want to show that for all s ∈ SNB (c), where c is some cell, we do not need any more information than the neighbourhood s to compute the transition of D ◦ B. For neighbourhoods s ∈ SNB (c) such that the left hand side of condition (1) is false, D always maps hB (s) to itself. Clearly in this case D does not create a dependence on a larger neighbourhood. Now consider neighbours s ∈ SNB (c) such that both sides of the implication (1) are true. The right side of (1) means that all next possible neighbourhoods of s must either be contained in the acting set of D, or completely separate from the acting set of D. So the particular neighbourhood that s actually gets mapped to by B is not important, since D already knows from s whether or not it will act. If next neighbourhoodB (s) ⊆ AD , then D will apply

318

A. Clarridge and K. Salomaa

fD to hB (s), and if next neighbourhoodB (s) is disjoint from AD , then D will apply the identity map to hB (s). Thus, we can compute the transition of D ◦ B at a cell c knowing just the current states of its neighbours, s. Conversely, assume that (1) does not hold. This means that for some s ∈ ¯ B (¯r1 ) ∈ AD and h ¯ B (¯r2 ) ∈ AD , ¯ NB (s) such that h SNB (c) there exist ¯r1 , ¯r2 ∈ S and that fD (hB (s)) = hB (s). Recall that ¯r1 and ¯r2 agree on the states of s, ¯ B denotes that function that maps a second order neighbourhood to and that h a neighbourhood of B. Consider a collection of cells in the configuration of ¯r1 . When we apply D ◦ B, the B automaton changes the states of s to a neighbourhood which is in AD . The D automaton is then applied. So the next state of the cell c is fD (hB (s)). On the other hand, consider a collection of cells in the configuration of ¯r2 . When we apply D ◦ B, the B automaton changes the states of s to a neighbourhood which is not in AD . The D automaton applies the identity map. So the next state of the cell c is hB (s). Since fD (hB (s)) = hB (s), this means that the CA D ◦ B cannot have the neighbourhood NB , since it depends on one or more of the states of ¯r1 and ¯r2 which differ and are outside of NB .

The condition of Proposition 1 can be used to inductively define a sequence of FDM CAs C1 , C2 , . . . , Cn such that C1 ◦C2 ◦· · ·◦Cn has the same neighbourhood as each of its components. One interesting property of FDM CAs is that a carefully chosen composition can represent any cellular automaton. Proposition 2. Every cellular automaton C with neighbourhood NC of size k and state space S can be represented exactly by a composition of |S|k + 1 FDM CAs with the same neighbourhood, if the FDM CAs are allowed |S| + |S|k states. The proof is a fairly straightforward construction and is omitted for brevity, but can be found in [15]. Note that the upper bounds on the number of FDM CA required in the composition and the number of extra states required are not meant to be tight. 3.2

Reversibility

We now discuss the reversibility of FDM CA. In the following text we use the notation s[0] to refer to the state in the ‘zero’ position of a neighbourhood vector s ∈ SN . Lemma 1. Let C = (d, S, N, AC , f ) be an FDM CA, and assume the cell itself is part of N (0 ∈ N ) without loss of generality. Denote B = {a ∈ AC | f (a[0]) = a[0]}. Then (d, S, N, B, f ) is equivalent with C.

A Cryptosystem Based on the Composition of Reversible Cellular Automata

319

Fig. 1. An example of an (N, N  )-neighbourhood mapping to an N  neighbourhood

Proof. The proof is immediate because tuples of AC not in B do not affect the computation in any way.

We say that an FDM CA C with acting set AC is reduced if for every a ∈ AC , f (a[0]) = a[0]. By Lemma 1, without loss of generality we can assume that an arbitrary FDM CA is reduced. We now generalize some of the definitions from Proposition 1 for an arbitrary FDM CA C=(d,S,N ,AC ,f ). Let an arbitrary neighbourhood be denoted by N  . Then let the (N, N  )neighbourhood of a neighbourhood s ∈ SN be the configuration containing the N neighbours of each of the elements in the N  neighbourhood. Let the set ¯ (N,N  ) (s). Note that an N of all (N, N  )-neighbourhoods of s be denoted by S  neighbourhood of an N -neighbourhood is the same as an N  -neighbourhood of an N -neighbourhood, which can be more formally stated as follows. Let r be a ¯ (N,N  ) (s) and let rN  be the ‘restriction’ of r to the neighbourhood vector in S  N , that is, rN  is an N  -neighbourhood around the zero-position. Then the (N  , N )-neighbourhood of rN  equals r. Let the transition function of C from (N, N  )-neighbourhoods to N  neigh¯ C , which takes an (N, N  )-neighbourhood configubourhoods be denoted by h ration and the neighbourhood N  as input, and outputs C’s action with that configuration on the neighbourhood of size N  . An illustration of an (N, N  )neighbourhood and how it maps to an N  neighbourhood is given in Figure 1. Let the transition function from neighbourhoods to sets of possible output neighbourhoods be denoted by ¯ C (¯r, N  ) | ¯r ∈ S ¯ (N,N  ) (s) }. next neighbourhoodC (s, N  ) = { h The following result characterizes when a given FDM CA with neighbourhood N has an FDM CA inverse with neighbourhood N  . Proposition 3. Let C be a reduced FDM CA (d,S,N ,AC ,f ). Denote  X= next neighbourhoodC (a, N  ). a∈AC

(2)

320

A. Clarridge and K. Salomaa

Then C has an FDM CA inverse with state set S and neighbourhood N  if and only if (∀ a ∈ / AC ) f (a[0]) = a[0] ⇒ next neighbourhoodC (a, N  ) ∩ X = ∅.

(3)

Proof. Assume condition (3) holds. Let us choose C −1 = (d, S, N  , AC −1 , f −1 ) where AC −1 = X, and show that it inverts C. Consider an arbitrary ¯r ∈ ¯ (N,N  ) (a) of a neighbourhood a ∈ SN , such that h ¯ C (¯r, N  ) = b (∈ SN  ). If S −1 a ∈ AC , then we know that b ∈ AC −1 so C will map b[0] to f −1 (b[0]) = a[0]. Now consider the case where a ∈ / AC . In this case we know that a[0] = b[0]. If f (a[0]) = a[0](= b[0]), then C −1 correctly maps b[0] back to itself since f −1 (b[0]) = b[0]. On the other hand, if f (a[0]) = a[0], then from (3) we know that b ∈ / AC −1 , and again C −1 must map b[0] to itself. Conversely, assume that C has an inverse FDM CA D with neighbourhood N  and let AD be the active set of D. Since D must correctly ‘map back’ all states where C applied the function f , it is clear that X (as defined in (2)) is a subset of AD . It remains to show that (3) holds. For the sake of contradiction assume that ¯ C (¯r, N  ) ∈ X, where ¯r is an (N, N  )-neighbourhood of a neighbourhood b=h a ∈ AC , and f (a[0]) = a[0]. Since a ∈ AC , we know that a[0] = b[0]. Since D is an inverse of C, the function used by D must be f −1 . Since b ∈ X ⊆ AD , the FDM CA D applies the function f −1 to b[0], but the result cannot be a[0] since that would imply f (a[0]) = b[0] = a[0], a contradiction.

The following corollary addresses the uniqueness of FDM CA inverses. Corollary 1. Let C and X be as defined in Proposition 3, and let C have some inverse C −1 with neighbourhood N  . Then C −1 is the only reduced FDM CA with neighbourhood N  that inverts C. Proof. Any inverse of C must have function f −1 . Assume for the sake of contradiction that there exists an FDM CA D with neighbourhood N  that inverts C and has acting set AD = X. In the proof of Proposition 3 we have observed that X must be a subset of AD . Thus it is sufficient to show that there cannot be an element b ∈ AD with b ∈ / X. ¯ (N,N  ) (a), a ∈ ¯ C (¯r, N  ), where ¯r ∈ S / AC since b ∈ / X. Then D Let b = h cannot be the inverse of C because C maps a[0] to itself, but D maps b[0] = a[0] to f −1 (b[0]), which cannot be equal to b[0] since b ∈ AD and D is reduced.

4

A Public-Key Cryptosystem

We want to use the idea of composing together many simple RCAs to form a complex RCA that is hard to invert, as outlined in the paper by Kari [11]. In order to make this idea work, we need to have some way to randomly generate a sequence of simple CAs such that the neighbourhood size of their composition remains small (or constant), and each CA in the composition is reversible.

A Cryptosystem Based on the Composition of Reversible Cellular Automata

321

We will demand that the neighbourhood size of each cellular automaton in the composition is the same, and that the entire composition has the same neighbourhood as any of the components. The components will all be FDM CAs. Since the neighbourhood, state set, and dimension are fixed, we must design an algorithm which generates acting sets and transition functions for each of the n components C1 , C2 , . . . , Cn . From the theory in the previous section, we can now state some requirements for such an algorithm. To maintain neighbourhood size during composition, the FDM CA Cj must have an acting set Aj and transition function fj such that the composition Cj ◦ (Cj−1 ◦ Cj−2 ◦ · · · ◦ C1 ) has the same neighbourhood, for all j ∈ {2, . . . , n}. Referring to the condition from Proposition 1, we need to guarantee that for each neighbourhood, the next neighbourhood set of Cj−1 ◦ Cj−2 ◦ · · · ◦ C1 is either completely contained in Aj or is disjoint from Aj . Denote by T ⊆ S the “change set”, that is, the set of all states that the composition Cj−1 ◦ Cj−2 · · · ◦ C1 can possibly change. One way we can be sure to retain neighbourhood size during composition is by setting Aj equal to the set of all neighbourhoods which contain a state in T . The condition from Proposition 1 is satisfied since all neighbourhoods containing states in T will certainly be mapped (by Cj−1 ◦ Cj−2 ◦ · · · ◦ C1 ) to neighbourhoods which also contain states in T (assuming f1 , f2 , . . . , fj−1 are one-to-one mappings), and neighbourhoods which do not contain any states in T will clearly be mapped to neighbourhoods which do not contain any states in T . We use a less restricted version of this principle (which still satisfies the neighbourhood size preservation condition) in our algorithm to determine the acting set of each FDM CA in a composition. The need for each of the FDM CAs in the composition to be invertible puts additional restrictions on their form. In order to be sure that the FDM CA is invertible, the set T which is used to find the acting set of each FDM CA must contain all states that the function f can change. The functions f1 , f2 , . . . , fn must also be permutations (one-to-one mappings). We discuss the key generation algorithm in more detail in Section 4.1. Once the component FDM CAs are generated, the public key is determined by sequentially applying C1 , C2 , . . . , Cn to each possible neighbourhood (using the neighbourhood as the starting configuration). The final state of the cell is recorded, and the public key is this mapping of neighbourhoods to states. The private key is not calculated explicitly; the CAs C1−1 , C2−1 , . . . , Cn−1 are simply applied sequentially for decryption. The message is encoded in a d dimensional grid and is evolved for a fixed number of iterations of the public key to produce the ciphertext. The ciphertext and number of iterations are sent as the encrypted message. 4.1

The Key Generation Algorithm

Our key generation scheme is given in Algorithm 1. We should note that in this algorithm, the random element function returns a random element from a given set, the random function returns a floating point number between 0.0 and 1.0, the random permutation function returns a random permutation mapping of a

322

A. Clarridge and K. Salomaa

given set, and the random binary function returns a random binary string of a given length. Also, the get all possible neighbourhoods function returns all possible neighbourhoods given a state set S and neighbourhood N . Input: State space S, Neighbourhood N , Number of FDM CA n, 0 < p, q < 1 Output: Set of reversible FDM CAs C1 , C2 , . . . , Cn Initialization T ←− ∅ T.add (random element (S)) T.add (random element (S−T)) all possible neighbourhoods ←− get all possible neighbourhoods (S,N ) for i ← 1 to n do The following code determines fi if random () < p and T = S then T.add (random element (S−T)) end fi ←− random permutation (T) The following code determines Ai binary string ←− random binary (|N |) Ai ←− ∅ for neighbourhood ∈ all possible neighbourhoods do unchanging neighbourhood ←− T rue for j ← 1 to |N | do if neighbourhood [j] ∈ T then unchanging neighbourhood ←− F alse if binary string [j] = 1 then Ai .add (neighbourhood) break end end end if unchanging neighbourhood = True and random () < q then Ai .add (neighbourhood) end end Ci ←− { S,N ,Ai ,fi } end

Algorithm 1. The public-key generation algorithm, discussed in Section 4.1 Initially T is a set T ⊆ S of two random elements of S. The FDM CAs in the composition are then constructed in order from C1 to Cn . Before choosing each Ci , with probability p a new element of S is added to the set T , and otherwise T stays the same. The function fi is chosen for each FDM CA to be a random permutation of the set T , and fi applies the identity map to states in S − T . The only remaining task is to select the acting set. For each FDM CA in the composition, a random binary string of length |N | is chosen. Every possible

A Cryptosystem Based on the Composition of Reversible Cellular Automata

323

neighbourhood is then considered as a candidate element of the acting set. If the candidate neighbourhood has a state which is an element of T and is also in a position corresponding to a ‘1’ of the binary string, then it is added to the acting set. Also, if the neighbourhood contains only states which are not in T , then the neighbourhood is added to the acting set with probability q. For example, consider the case where S = {a, b, c}, N = {−1, 1}, T = {a, b}, and the random binary string is 01. Then the neighbourhood ca is a member of the acting set while ac is not, and cc will become a member of the acting set with probability q. Note that if the neighbourhood N contains the zero element, then clearly the case where the neighbourhood is added to the acting set with probability q is irrelevant since not even the state of the cell can change. We now discuss the correctness of this algorithm, and begin by showing that the condition for constant neighbourhood size during composition holds. Assume we are attempting to determine the acting set of the ith FDM CA in the composition, Ai , and let us first consider neighbourhoods which have at least one state in T . If a neighbourhood is in Ai , then at least one element of T occurring in the neighborhood corresponds to a ‘1’ in the binary string. Since Ci ◦ Ci−1 ◦ · · · ◦ C1 is T -invariant (states in T are mapped to states in T ), the neighbourhood will certainly be mapped to a neighbourhood in Ai . On the other hand, if a neighbourhood is not in Ai , then all occurrences of states in T correspond to ‘0’ elements of the binary string. This neighbourhood is mapped to a neighbourhood where states in T also correspond to ‘0’ elements of the binary string, and hence it is mapped to a neighbourhood which is not in Ai . Finally, a neighbourhood which contains no elements of T satisfies the condition of Proposition 1 since it must map to itself. It remains to show that the condition for FDM CA reversibility holds for each Ci . Rather conveniently, the previous conditions actually allow (or demand) that Ai is also the acting set of the inverse FDM CA. Since any addition to the set T during the construction of each FDM CA happens before we choose Ai , we are guaranteed that elements of Ai will be mapped to elements of Ai , and elements not in Ai will not be mapped to Ai . So the condition from Proposition 3 also holds. We could not be sure of this if Ai was constructed with some T that did not correspond with the states that fi changes. Note that Algorithm 1 has running time exponential in neighbourhood size. 4.2

Security Concerns and Practical Considerations

Since the FDM CA compositions follow a specific form and are not general twodimensional RCA, we cannot directly use Kari’s result [13] to justify the security of the system, and hence the security of this cryptosystem is largely unknown to us. However, we do not believe that straightforward brute force attacks will work. If one attempted to guess at a composition of FDM CAs which resulted in the same public key, there are many choices for each CA and there are n! ways to arrange them, since n is the number of CAs in the composition. One could also attempt to keep track of all global inputs and outputs for a fixed grid size in order to invert the composed CA. In this case the number of possible global

324

A. Clarridge and K. Salomaa

configurations is |S|(g) where g is the number of grid cells, so as long as the grid (the message) is relatively large this method will not work. We also do not believe that the inverse C1−1 ◦ C2−1 ◦ · · · ◦ Cn−1 can be guessed very easily. Although we do not calculate it explicitly, this CA must have a fairly large neighbourhood because for each composition in the sequence, the condition from Proposition 1 does not hold in general. Each time T changes during the generation of the FDM CA, the inverse automaton’s neighbourhood size may increase, and this can happen at most |S| − 2 times. So there is a computable upper bound for the neighbourhood size of the inverse, given C1 , C2 , . . . , Cn , but for reasonably large S and d > 1 this probably does not pose a security threat. A user must choose the parameters of our algorithm with some care in order to prevent these brute force attacks and also to be able to encrypt and decrypt within a reasonable amount of time on a normal computer. An example is N = {(0, 1), (1, 0)} (the top and right neighbours), |S| ≈ 25, grid size g ≈ 500, number of FDM CA in the composition n ≈ 100, p = q = 0.5, and number of iterations ≈ 100. These sizes can probably be increased significantly if the algorithm were implemented on specialized parallel hardware (especially the grid size and number of iterations). We should note that the expected number of CA needed in the composition to just achieve T = S is (|S|− 2)·1/p, and so n should be chosen so that it is significantly larger than this quantity. If n is too small, then the composition will only change states in T , and all elements in S − T that occur in the original message will occur in the same places in the ciphertext. One security issue related to the last point is that with our key generation algorithm as written, it is very easy for an attacker to determine which state was last added to T . The public key will map this state to some other state regardless of the neighbourhood. Not much can be immediately done with this information, but perhaps it could be a starting point for a clever cryptanalytic algorithm to find each of the FDM CA in the composition in backwards order.

5

Conclusion and Future Work

We presented conditions which guarantee that compositions of fixed-domain marker cellular automata have the same neighbourhood as each of the individual components. We showed that, under certain technical assumptions, an FDM CA has a unique inverse with a given neighbourhood. We used these results to design, present, and show the correctness of a working key generation algorithm for a public-key cryptosystem originally conceived by Kari [11]. We also provided some preliminary cryptanalysis and gave some practical implementation notes. This work provides several avenues for further research. We have given perhaps a more manageable definition of marker cellular automata, which could facilitate or help with additional theoretical development in related areas. The security of the cryptosystem presented in this work is currently unknown, and serious cryptanalysis is needed before more can be said in this regard. When generating the public key, there may be some alternate or more general way to choose the component CAs to produce a more efficient or secure system. If the cryptosystem

A Cryptosystem Based on the Composition of Reversible Cellular Automata

325

does not break easily then it would make sense to try to design an optimal hardware implementation and to do a corresponding feasibility analysis for realworld applications.

References 1. Tao, R., Chen, S.: On finite automaton public-key cryptosystem. Theoretical Computer Science 226(1-2), 143–172 (1999) 2. Charbouillot, S., Perez, A., Fronte, D.: A programmable hardware cellular automaton: Example of data flow transformation. In: 13th IEEE International Conference on Electronics, Circuits and Systems, pp. 1232–1235 (2006) 3. Franti, E., Slav, C., Balan, T., Dascalu, M.: Design of cellular automata hardware for cryptographic applications. In: CAS 2004 Int. Semiconductor Conference, vol. 2, pp. 463–466 (2004) 4. Zheng, Y., Imai, H.: A cellular automaton based fast one-way hash function suitable for hardware implementation. In: Imai, H., Zheng, Y. (eds.) PKC 1998. LNCS, vol. 1431, pp. 217–234. Springer, Heidelberg (1998) 5. Anghelescu, P., Ionita, S., Sofron, E.: Block encryption using hybrid additive cellular automata. In: HIS 2007: Proceedings of the 7th International Conference on Hybrid Intelligent Systems, Washington, DC, USA, pp. 132–137. IEEE Computer Society, Los Alamitos (2007) 6. Gutowitz, H.: Cryptography with dynamical systems. In: Goles, E., Boccara, N. (eds.) Cellular Automata and Cooperative Phenomena, pp. 237–274 (1993) 7. Gutowitz, H.: Method and apparatus for encryption, decryption, and authentication using dynamical systems. U.S. Patent 5365589 (1994) 8. Seredynski, M., Bouvry, P.: Block cipher based on reversible cellular automata. Congress on Evolutionary Computation 2, 2138–2143 (2004) 9. Srebrny, M., Such, P.: Encryption using two-dimensional cellular automata with applications. Artificial intelligence and Security in Computing Systems, 203–215 (2003) 10. Wolfram, S.: Random sequence generation by cellular automata. Advances in Applied Mathematics 7(2), 163–169 (1986) 11. Kari, J.: Cryptosystems based on reversible cellular automata (manuscript, 1992) 12. Amoroso, S., Patt, Y.: Decision procedures for surjectivity and injectivity of parallel maps for tesselation structures. J. Comput. System Sci. 6, 448–464 (1972) 13. Kari, J.: Reversibility and surjectivity problems of cellular automata. J. Comput. System Sci. 48, 149–182 (1994) 14. Ashley, J.: Marker automorphisms of the one-sided d-shift. Ergodic Theory Dynam. Systems 10(2), 247–262 (1990) 15. Clarridge, A., Salomaa, K.: A cryptosystem based on the composition of reversible cellular automata. Technical Report 2008-549, Queen’s University, School of Computing (2008)

Grammars Controlled by Special Petri Nets J¨ urgen Dassow1 and Sherzod Turaev2 1

Otto-von-Guericke-Universit¨ at Magdeburg PSF 4120, D-39016 Magdeburg, Germany [email protected] 2 GRLMC, Universitat Rovira i Virgili Pl. Imperial T` arraco 1, 43005 Tarragona, Spain [email protected]

Abstract. A Petri net controlled grammar is a context-free grammar with a control by a Petri net whose transitions are labeled with rules of the grammar or the empty string and the associated language consists of all terminal strings which can be derived in the grammar and the sequence of rules in a derivation is in the image of a successful occurrence of transitions of the net. We present some results on the generative capacities of such grammars that Petri nets are restricted to some known structural subclasses of Petri nets.

1

Introduction

A Petri net controlled grammar is a context-free grammar with a control by a Petri net whose transitions are labeled with rules of the grammar or the empty string and the associated language consists of all terminal strings which can be derived in the grammar and the sequence of rules in a derivation is in the image of a successful occurrence of transitions of the net. In [1] we investigated arbitrary Petri net controlled grammars in dependence on the type of labeling (a bijection, coding and weak coding) and on the use of final markings (a finite set of final markings and the set of all reachable markings). In this paper we investigate grammars controlled by some special subclasses of Petri nets, which corresponds to investigations in grammars with controlled derivations where arbitrary regular sets are substituted by some special subregular sets, e.g. in case of regularly controlled grammars and tree controlled grammars, see [2] and [3]. The paper is organized as follows. In Section 2 we give some notions and definitions from the theories of formal languages and Petri nets. In Section 3 we introduce the concept of a control of derivations in context-free grammars by special Petri nets. In Section 4 we investigate the effect of labeling on the power of the introduced families of languages. In Section 5 we discuss the effect of different types of final markings on the generative power and give some characterizations by other regulated grammars. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 326–337, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Grammars Controlled by Special Petri Nets

2

327

Definitions

Throughout the paper, we assume that the reader is familiar with the basic concepts of the theories of formal languages and Petri nets; for details we refer to [4,5,6,7]. Let Σ be an alphabet. A string over Σ is a sequence of symbols from the alphabet. The set of all strings over the alphabet Σ is denoted by Σ ∗ . A subset L of Σ ∗ is called a language. A string u = u1 u2 · · · un , u1 , u2 , . . . , un ∈ Σ is a scattered substring of v ∈ Σ ∗ if v = v1 u1 v2 · · · un vn+1 for some v1 , v2 , . . . , vn+1 ∈ Σ ∗ with n ≥ 1. The length of a string w is denoted by |w|, and the number of occurrences of a symbol a in a string w by |w|a . The empty string is denoted by λ which is of length 0. A string u1 v1 u2 v2 · · · un vn is called a shuffle of strings u = u1 u2 · · · un and v = v1 v2 · · · vn where ui , vi ∈ Σ ∗ , 1 ≤ i ≤ n. A shuffle of u and v is proper if it is not a concatenation of u and v or v and u. A shuffle of u1 , u2 , . . . , un , n ≥ 3 is a shuffle of a shuffle of u1 , u2 , . . . , un−1 and un . A shuffle of u1 , u2 , . . . , un , n ≥ 2, is semi if for some 1 ≤ i < j ≤ n, ui = uj , then a proper shuffle of ui and uj is not its scattered substring, in words, a semi-shuffle string does not contain self-shuffled scattered substrings. A context-free grammar is a quadruple G = (V, Σ, S, R) where V and Σ are the disjoint finite sets of nonterminal and terminal symbols, respectively, S ∈ V is the start symbol and the finite set R ⊂ V × (V ∪ Σ)∗ is the set of (production) rules. Usually, a rule (A, x) is written as A → x. A rule of the form A → λ is called an erasing rule. The word x ∈ (V ∪ Σ)+ directly derives y ∈ (V ∪ Σ)∗ , written as x ⇒ y, iff there is a rule r = A → α ∈ R such that x = x1 Ax2 and y = x1 αx2 . The reflexive and transitive closure of ⇒ is denoted by ⇒∗ . A r1 r2 ···rn π derivation using the sequence of rules π = r1 r2 · · · rn is denoted by = ⇒ or == ===⇒. ∗ ∗ The language generated by G is defined by L(G) = {w ∈ Σ | S ⇒ w}. A regularly controlled grammar is a quintuple G = (V, Σ, S, R, K) where V, Σ, S, R are specified as in a context-free grammar and K is a regular set over R. The language generated by G consists of all words w ∈ Σ ∗ such that r1 r2 ···rn there is a derivation S == ===⇒ w where r1 r2 · · · rn ∈ K. A matrix grammar is a quadruple G = (V, Σ, S, M ) where V, Σ, S are defined as for a context-free grammar, M is a finite set of matrices which are finite strings over a set of context-free rules. The language generated by the grammar r1 r2 ···rn ===⇒ w G consists of all strings w ∈ Σ ∗ such that there is a derivation S == where r1 r2 · · · rn is a concatenation of some matrices mi1 , mi2 , . . . , mik ∈ M . A vector grammar is a quadruple G = (V, Σ, S, M ) whose components are defined as for a matrix grammar. The language generated by the grammar G r1 r2 ···rn ===⇒ w where consists of all strings w ∈ Σ ∗ such that there is a derivation S == r1 r2 · · · rn is a shuffle of some matrices mi1 , mi2 , . . . , mik ∈ M . A semi-matrix grammar is a quadruple G = (V, Σ, S, M ) whose components are defined as for a matrix grammar. The language generated by the grammar r1 r2 ···rn ===⇒ w G consists of all strings w ∈ Σ ∗ such that there is a derivation S == where r1 r2 · · · rn is a semi-shuffle of some matrices mi1 , mi2 , . . . , mik ∈ M .

328

J. Dassow and S. Turaev

A matrix (semi-matrix, vector) grammar G is called without repetitions, if each rule r occurs in M = {m1 , m2 , . . . , mn } only once, i.e., |m1 m2 · · · mn |r = 1. For each matrix grammar, by adding chain rules, one can construct an equivalent matrix grammar without repetitions. The families of languages generated by regularly controlled, matrix, vector and semi-matrix grammars (with erasing rules) are denoted by rC, MAT, V and sMAT (rCλ , MATλ , Vλ and sMATλ ), respectively. It is known that rC = MAT ⊆ V and rCλ = MATλ = Vλ = sMATλ (see [8], [9]). A Petri net (PN) is a construct N = (P, T, F, ϕ) where P and T are disjoint finite sets of places and transitions, respectively, F ⊆ (P × T ) ∪ (T × P ) is the set of directed arcs, ϕ : F → {1, 2, . . . } is a weight function. A Petri net can be represented by a bipartite directed graph with the node set P ∪ T where places are drawn as circles, transitions as boxes and arcs as arrows with labels ϕ(p, t) or ϕ(t, p). If ϕ(p, t) = 1 or ϕ(t, p) = 1, the label is omitted. A mapping μ : P → {0, 1, 2, . . .} is called a marking. For each place p ∈ P , μ(p) gives the number of tokens in p. Graphically, tokens are drawn as small solid dots inside circles. • x = {y | (y, x) ∈ F } and x• = {y | (x, y) ∈ F } are called  pre• • X = and post-sets of x ∈ P ∪ T , respectively. For X ⊆ P ∪ T , define x∈X x  • • • • and X = x∈X x . The elements of t ( p) are called input places (transitions) and the elements of t• (p• ) are called output places (transitions) of t (p). A sequence of places and transitions ρ = x1 x2 · · · xn is called a path if and only if no place or transition except x1 and xn appears more than once, and xi+1 ∈ x•i for all 1 ≤ i ≤ n − 1. A path ρ = x1 x2 · · · xn is a cycle if x1 = xn . By Pρ , Tρ , Fρ the sets of places, transitions, and arcs of a path ρ are denoted. The sequence of transitions in a path ρ is denoted by tr(ρ). A transition t ∈ T is enabled by marking μ iff μ(p) ≥ ϕ(p, t) for all p ∈ P . In this case t can occur (fire). Its occurrence transforms the marking μ into the marking μ defined for each place p ∈ P by μ (p) = μ(p) − ϕ(p, t) + ϕ(t, p). A finite sequence t1 t2 · · · tk of transitions is called an occurrence sequence enabled t1 tk t2 μ1 −→ . . . −→ at a marking μ if there are markings μ1 , μ2 , . . . , μk such that μ −→ t1 t2 ···tk ν −−−→ μk or μ − → μk where μk . In short this sequence can be written as μ −− ν = t1 t2 · · · tk . For each 1 ≤ i ≤ k, the marking μi is called reachable from the marking μ. A marked Petri net is a system N = (P, T, F, ϕ, ι) where (P, T, F, ϕ) is a Petri net, ι is the initial marking. Let M be a set of markings, which will be called final markings. An occurrence sequence ν of transitions is called successful for M if it is enabled at the initial marking ι and finished at a final marking τ of M . An ordinary net (ON) is a Petri net N = (P, T, F, ϕ, ι) where ϕ(x, y) = 1 for all (x, y) ∈ F . We omit ϕ from the definition of an ordinary net. We regard the following main structural subclasses of Petri nets. A state machine (SM) is an ordinary Petri net such that |• t| = |t• | = 1 for all t ∈ T. A marked graph (MG) is an ordinary Petri net such that |• p| = |p• | = 1 for all p ∈ P .

Grammars Controlled by Special Petri Nets

SM

329

GSM FC

MG

EFC

AC

ON

PN

GMG CN

Fig. 1. The hierarchy of Petri net classes

A generalized state machine (GSM) is an ordinary Petri net such that |• t| ≤ 1 and |t• | ≤ 1 for all t ∈ T . A generalized marked graph (GMG) is an ordinary Petri net such that |• p| ≤ 1 and |p• | ≤ 1 for all p ∈ P . A casual net (CN) is a generalized marked graph each subgraph of which is not a cycle. A free-choice net (FC) is an ordinary Petri net such that if p•1 ∩ p•2 = ∅ then • |p1 | = |p•2 | = 1 for all p1 , p2 ∈ P . An extended free-choice net (EFC) is an ordinary Petri net such that if p•1 ∩ • p2 = ∅ then p•1 = p•2 for all p1 , p2 ∈ P . An asymmetric choice net (AC) is an ordinary Petri net such that if p•1 ∩p•2 = ∅ then p•1 ⊆ p•2 or p•1 ⊇ p•2 for all p1 , p2 ∈ P . The hierarchy of the introduced subclasses of Petri nets is shown in Fig. 1 where the arrows denote proper inclusions of the left families into the right families.

3

Grammars and Their Languages

We introduce the concept of control by special Petri nets. Definition 1. A Petri net controlled grammar (in short a PN controlled grammar) is a tuple G = (V, Σ, S, R, N, γ, M ) where V , Σ, S, R are defined as for a context-free grammar, N = (P, T, F, ι) is a Petri net, γ : T → R ∪ {λ} is a transition labeling function and M is a set of final markings. If a Petri net is a (generalized) state machine, (generalized) marked graph, causal net, (extended) free-choice net, asymmetric choice net or ordinary net, then we call a (generalized) state machine, (generalized) marked graph, causal net, (extended) free-choice net, asymmetric choice net or ordinary net controlled grammar, respectively. We also use the common name a special Petri net (sPN) when we refer to each sub-class. Definition 2. The language generated by a PN controlled grammar G consists π ⇒ w ∈ Σ ∗ , π = r1 r2 · · · rk , of all strings w ∈ Σ ∗ such that there is a derivation S = and a successful occurrence sequence ν = t1 t2 · · · ts for M such that π = γ(ν).

330

J. Dassow and S. Turaev λ

•

A → aA

B → aB

A→λ

B→λ

A → bA

B → bB

S → AB p

λ

Fig. 2. A state machine N1

(This definition uses the extended form of the transition labeling function γ : T ∗ → R∗ ; this extension is done in the usual manner.) Different labeling strategies and different definitions of the set of final markings result various types of Petri net controlled grammars. In this paper we consider the following types of Petri net controlled grammars. A Petri net controlled grammar is called free (abbreviated by f ), λ-free (abbreviated by −λ) or extended (abbreviated by λ) if γ is a bijection (the labels of the transitions are distinct and non-null), a coding (different transitions may be labeled with the same symbol) or a week coding (transitions may be labeled with λ), respectively. A Petri net controlled grammar is of r-type, t-type or g-type if M is the set of all reachable markings, the finite set of markings or a set of any markings which is greater or equal to an element of a given finite set M0 of markings, respectively. We use the notation a (x, y)-PN controlled grammar where x ∈ {f, −λ, λ} shows the type of a labeling function and y ∈ {r, t, g} shows the type of a set of final markings. We denote the families of languages generated by grammars controlled by state machines, generalized state machines, marked graphs, generalize marked graphs, causal nets, free-choice nets, extended free-choice nets, asymmetric nets, ordinary nets and petri nets (with erasing rules) by SM(x, y), GSM(x, y), MG(x, y), GMG(x, y), CN(x, y), FC(x, y), EFC(x, y), AC(x, y), ON(x, y), PN(x, y) (SMλ (x, y), GSMλ (x, y), MGλ (x, y), GMGλ (x, y), CNλ (x, y), FCλ (x, y), EFCλ (x, y), ACλ (x, y), ONλ (x, y), PNλ (x, y)), respectively, where x ∈ {f, −λ, λ} and y ∈ {r, t, g}. We use bracket notation Y[λ] for a language family Y in order to say that a statement holds both in case of with erasing rules and in case of without erasing rules.

Grammars Controlled by Special Petri Nets

331

S → AB

λ

A → aA

B → aB

A → bA

B → bB

A→λ

B→λ

Fig. 3. A marked graph N2

For x ∈ {f, −λ, λ} and y ∈ {r, t, g}, the inclusion Y(x, y) ⊆ Yλ (x, y) is obvious where Y ∈ {SM, GSM, MG, GMG, CN, FC, EFC, AC, ON}. Example 1. Let G1 = ({S, A, B}, {a, b}, S, R, N1, γ1 , M1 ) be a state machine controlled grammar where R = {S → AB, A → aA|bA|λ, B → aB|bB|λ}, N1 which is illustrated in Fig. 2 is a state machine and M1 = {μ} where μ(p ) = 1 and μ(p) = 0 for all p ∈ P − {p }, then L(G1 ) = {ww | w ∈ {a, b}∗}. Example 2. Let G2 = ({S, A, B}, {a, b}, S, R, N2, γ2 , M2 ) be a marked graph controlled grammar where R is the same as in Example 1, a marked graph N2 is illustrated in Fig. 3 and M1 = {μ} where μ(p) = 0 for all p ∈ P . Then L(G2 ) = {ww | w ∈ {a, b}∗ and w ∈ Perm(w)}.

4

Results: Labeling Strategies

In this section we investigate the effect of the labeling of transitions on the generative capacities of the introduced families of languages. From the definition, the next statement follows immediately. Lemma 1. For Y ∈ {SM, GSM, MG, GMG, CN, FC, EFC, AC, ON} and y ∈ {r, t, g}, Y[λ] (f, y) ⊆ Y[λ] (−λ, y) ⊆ Y[λ] (λ, y). Further, we show that the reverse inclusions also hold. For each sPN, one can easily construct a net of the same type in which the transitions have different labels, by “splitting” each transition into two, i.e., by replacing a transition t with label A → α by new transitions t , t with labels A → A , A → α, respectively, where t receives all incoming arcs of t and t receives all outgoing arcs of t, and a new place pt from transition t and to transition t . Lemma 2. For Y ∈ {SM, GSM, MG, GMG, CN, FC, EFC, AC, ON} and y ∈ {r, t, g}, Y[λ] (−λ, y) ⊆ Y[λ] (f, y).

332

J. Dassow and S. Turaev

For each (λ, y)-sPN controlled grammar, if we label each λ-transition with X → X, start each derivation with S  → SX and erase X with rule X → λ at the end of the derivation, then we get the same derivation in a (−λ, y)-sPN controlled grammar, i.e., Lemma 3. For Y ∈ {SM, GSM, MG, GMG, CN, FC, EFC, AC, ON} and y ∈ {r, t, g}, Yλ (λ, y) ⊆ Yλ (−λ, y). It is known that by structure state machines and finite automata are the same. We can remove λ-transitions of a state machine by using an analogous method to λ-transition removal operation in finite automata. Lemma 4. For y ∈ {r, t, g} and Y ∈ {SM, GSM}, Y(λ, y) ⊆ Y(−λ, y). Lemma 5. For x ∈ {f, −λ, λ} and y ∈ {r, t, g}, GMG[λ] (x, y) ⊆ MG[λ] (x, y). Proof. Let G = (V, Σ, S, R, N, γ, M ) be a (x, y)-GMG controlled grammar (with or without erasing rules) where N = (P, T, F, ι) is a generalized marked graph. Let P∅− = {p ∈ P | • p = ∅} and P∅+ = {p ∈ P | p• = ∅}. Without loss of generality we can assume that P∅− ∩ P∅+ = ∅ (if place p ∈ P is isolated, i.e., |• p| = |p• | = 0, it can be eliminated since isolated places do not effect any derivation of the grammar). Let Q− = {qp | p ∈ P∅− } and Q+ = {qp | p ∈ P∅+ } be the sets of new places, − T = {tp | p ∈ P∅− } and T + = {tp | p ∈ P∅+ } be the sets of new transitions and F − = {(tp , qp ), (qp , tp ), (tp , p) | p ∈ P∅− } and F + = {(p, tp ), (tp , qp ), (qp , tp ) | p ∈ P∅+ } be the sets of new arcs. We construct a MG N  = (P ∪ Q− ∪ Q+ , T ∪ T − ∪ T + , F ∪ F − ∪ F + , ι ) where  ι (p) = ι(p) if p ∈ P and ι (p) = 0 if p ∈ Q− ∪ Q+ . We set V  = V ∪ {B} and R = R ∪ {B → B} where B is a new nonterminal symbol, and define a MG controlled grammar G = (V  , Σ, S, R , N  , γ  , M  ) where the labeling function γ  is defined by γ  (t) = γ(t) if t ∈ T and γ  (t) = B → B if t ∈ T − ∪ T + . For each τ  ∈ M  , τ  (p) = τ (p) if p ∈ P and τ  (p) = 0 if p ∈ Q− ∪ Q+ . By construction of N  , any transition t ∈ T − ∪ T + never occurs and the production rule B → B is never applied in any derivation of G . Thus it is not difficult to see that L(G) = L(G ).   We state the following lemma without proof. Lemma 6. For y ∈ {r, t, g} and Y ∈ {MG, CN}, Y(λ, y) ⊆ Y(−λ, y). Using the same arguments of the proof of Lemma 7 in [1] we can show that the next statement holds. Lemma 7. Y(λ, y) ⊆ Y(−λ, y) for Y ∈ {EFC, AC, ON} and y ∈ {r, t, g}. Lemma 8. PN[λ] (λ, y) ⊆ FC[λ] (λ, y) for y ∈ {r, t, g}.

Grammars Controlled by Special Petri Nets

333

Proof. Let G = (V, Σ, S, R, N, γ, M ) be a Petri net controlled grammar (with or without erasing rules) where N = (P, T, F, ϕ, ι). For each arc (p, t) ∈ F , we introduce new places pi [p, t], new transitions ti [p, t] and new arcs (p, ti [p, t]), (ti [p, t], pi [p, t]), (pi [p, t], t) whose weights are 1’s, 1 ≤ i ≤ ϕ(p, t), and for each arc (t, p) ∈ F , we introduce new places pj [t, p], new transitions tj [t, p] and new arcs (t, pj [t, p]), (pj [t, p], tj [t, p]), (tj [t, p], p) whose weights are 1’s, 1 ≤ j ≤ ϕ(t, p). Let PF ={pi [p, t] | (p, t) ∈ F, 1 ≤ i ≤ ϕ(p, t)} ∪ {pj [t, p] | (t, p) ∈ F, 1 ≤ j ≤ ϕ(t, p)}, TF ={ti [p, t] | (p, t) ∈ F, 1 ≤ i ≤ ϕ(p, t)} ∪ {tj [t, p] | (t, p) ∈ F, 1 ≤ j ≤ ϕ(t, p)}, F  ={(p, ti [p, t]), (ti [p, t], pi [p, t]), (pi [p, t], t) | (p, t) ∈ F, 1 ≤ i ≤ ϕ(p, t)} ∪ {(t, pj [t, p]), (pj [t, p], tj [t, p]), (tj [t, p], p) | (t, p) ∈ F, 1 ≤ j ≤ ϕ(t, p)}. We construct a net N  = (P ∪ PF , T ∪ TF , F  , ι ) where the initial marking ι is defined by ι (p) = ι(p) for all p ∈ P and ι (p) = 0 for all p ∈ PF . Let • t = {p1 , p2 , . . . , pk } for a transition t ∈ T in N . Then for this transition k in N  we have • t = i=1 {pj [pi , t] | 1 ≤ j ≤ ϕ(pi , t)} and (pj [pi , t])• = {t} for all 1 ≤ i ≤ k and 1 ≤ j ≤ ϕ(pi , t). It follows that N  is a free-choice net. We define a free-choice net controlled grammar G = (V, Σ, S, R, N  , γ  , M  ) where the components V, Σ, S, R are defined as for the grammar G, the freechoice net N  is constructed above. We set γ  (t) = γ(t) if t ∈ T and γ  (t) = λ if t ∈ TF ; for each τ  ∈ M  , τ  (p) = τ (p) if p ∈ P , and for p ∈ PF , τ  (p) = 0 if y ∈ {g, t}, otherwise 0 ≤ τ  (p) ≤ τ  (p ) where p ∈ • (• p). r1 r2 ···rm ===⇒ w ∈ Σ ∗ be a derivation in G. Then there is a sucLet D : S == cessful occurrence sequence of transitions ν = t1 t2 · · · tn for M in N such that γ(ν) = r1 r2 · · · rm . We replace ν by ν  = ν1 t1 ν2 · · · νn tn in N  where for all 1 ≤ i ≤ n, νi ∈ Perm(• (• ti )) where • (• ti ) = {tj [pil , ti ] | 1 ≤ j ≤ ϕ(pil , ti ), 1 ≤ i ≤ n, 1 ≤ l ≤ s}. In order to fire each ti , 1 ≤ i ≤ n, in N  , we need to fire all transitions of • • ( ti ) at least once, therefore, ν  is successful for M  and r1 r2 · · · rm = γ  (ν  ), i.e., D is a derivation in G . Let t1 t2 · · · tn be a successful occurrence sequence for M  . By construction, each occurrence of ti , 1 ≤ i ≤ n, needs at least one occurrence of all transitions of • • λ ( ti ). Without loss of generality we can assume that ν = ν1λ σ1λ t1 ν2λ · · · σnλ tn νn+1   ϕ(p ,t ) i i s where σiλ = l=1 j=1 l tj [pil , ti ], 1 ≤ i ≤ n, and νiλ ∈ TF∗ , 1 ≤ i ≤ n + 1. s ϕ(pil ,ti ) We replace l=1 j=1 tj [pil , ti ]ti by ti , 1 ≤ i ≤ n, and erase νiλ , 1 ≤ i ≤ n + 1. The obtained occurrence sequence ν  = t1 t2 · · · tn is successful for M in r1 r2 ···rn N . Then a derivation S == ===⇒ w ∈ Σ ∗ in G where r1 r2 · · · rn = γ  (ν) is also a derivation in G and r1 r2 · · · rn = γ  (ν  ).   The immediate consequence of this lemma is Corollary 1. Y[λ] (λ, y) ⊆ FC[λ] (λ, y) where Y ∈ {EFC, AC, ON} and y ∈ {r, g, t}.

334

J. Dassow and S. Turaev

Lemma 9. For y ∈ {r, t, g}, FC(λ, y) ⊆ FC(−λ, y). From the presented lemmas above, we can conclude that the labeling strategies of transitions of special Petri nets do not effect on the generative powers of the families of languages generated by grammars controlled by these nets. Theorem 1. For Y ∈ {SM, GSM, MG, GMG, CN, FC, EFC, AC, ON}, Y[λ] (f, y) = Y[λ] (−λ, y) = Y[λ] (λ, y) where y ∈ {r, t, g}.

5

Results: Final Markings

In this section, we give some characterizations of the classes of languages generated by sPN controlled grammars by other classes of regulated languages. From the structural properties of special Petri nets and Lemmas 5, 8, the next statement follows immediately Theorem 2. For Y ∈ {FC, EFC, AC, ON} and x ∈ {f, −λ, λ}, y ∈ {r, g, t}, SM(x, y) ⊆ GSM(x, y) ⊆ Y(x, y) ⊆ Yλ (x, y), CN(x, y) ⊆ MG(x, y) = GMG(x, y) ⊆ Y(x, y) ⊆ Yλ (x, y). Lemma 10. SM[λ] (λ, r) ⊆ SM[λ] (λ, t). Proof. Let G = (V, Σ, S, R, N, γ, M ) be a state machine controlled grammar (with or without erasing rules) where N = (P, T, F, ι). Since the firing of a transition in a state machine moves one token from the input place to the output place, the number of tokens in the net remains the same in any firing of a transition. It follows that the set M of all reachable markings is finite, i.e.,   n+k−1 |M | ≤ k−1 n+k−1  where n = p∈P ι(p) and k = |P | ( k−1 is the number of solutions in non  negative integers to the equation x1 + x2 + · · · + xk = n, see [10]). From Lemma 10 the next statements follow immediately Corollary 2. SM[λ] (λ, r) ⊆ SM[λ] (λ, g) and SM[λ] (λ, g) ⊆ SM[λ] (λ, t). We state the following lemma without proof. Lemma 11. SM[λ] (λ, t) ⊆ SM[λ] (λ, r). Lemma 12. MAT[λ] ⊆ SM[λ] (f, t). Proof. Let G = (V, Σ, S, M ) be a matrix grammar (with or without erasing rules) and M = {m1 , m2 , . . . , mn } where mi = ri1 ri2 · · · rik(i) , 1 ≤ i ≤ n. Without loss of generality we can assume that G is without repetitions. Let

Grammars Controlled by Special Petri Nets

335

R = {rij | 1 ≤ i ≤ n, 1 ≤ j ≤ k(i)}. We define a (f, t)-SM controlled grammar G = (V, Σ, S, R, N, γ, {μ}) where the sets of places, transitions and arcs of the a SM N = (P, T, F, ι) are defined by P = {p0 } ∪ {pij | 1 ≤ i ≤ n, 1 ≤ j ≤ k(i) − 1}, T = {tij | 1 ≤ i ≤ n, 1 ≤ j ≤ k(i)} and F ={(p0 , ti1 ), (tik(i) , p0 ) | 1 ≤ i ≤ n} ∪ {(pik(i)−1 , tik(i) ) | 1 ≤ i ≤ n} ∪ {(tij , pij ) | 1 ≤ i ≤ n, 1 ≤ j ≤ k(i) − 1}. The initial marking is defined by ι(p0 ) = 1, and ι(p) = 0 for all P − {p0 }. The bijection γ : T → R is defined by γ(tij ) = rij , 1 ≤ i ≤ n, 1 ≤ j ≤ k(i) and the final marking μ is the same as the initial marking ι. mil mi1 mi2 Let S = w0 ==⇒ w1 ==⇒ · · · ==⇒ wl = w ∈ Σ ∗ be a derivation in G, where mij

rij 1 rij 2 ···rij k(ij )

mij ∈ M , 1 ≤ j ≤ l, and wj−1 ==⇒ wj : wj−1 ===========⇒ wj . By definition of γ, γ −1 (mij ) = σj where σj = tij 1 tij 2 · · · tij k(ij ) for all 1 ≤ j ≤ l. Then the σ σ2 ···σl occurrence sequence of transitions ι −−1−− −−→ ι is a successful for {μ}. Therefore, mi1 mi2 ···mi

l S ========⇒ wl ∈ Σ ∗ is a derivation in G . The inverse inclusion can also be shown using the same arguments.

 

Lemma 13. For y ∈ {r, g, t}, SM[λ] (λ, y) ⊆ rC[λ] . Proof. Let G = (V, Σ, S, R, N, γ, M ) be a SM controlled grammar (with or without erasing rules) where N = (P, T, F, ι). We construct a (deterministic) finite automaton A whose states are the markings of the net N (since the set of all reachable markings of a state machine is finite, it can be considered as a set of states) and there is an arc from state μ to state μ with label t iff marking μ is obtained from marking μ by firing transition t. The initial marking is considered as the initial state and the set of final markings M as a set of final states. Formally, A = (M  , T, ι, δ, M ) where M  is the set of all reachable markings of the net N and the state-transition function δ : M  × T → M  is defined by t δ(μ, t) = μ iff μ − → μ . It is not difficult to see that σ = t1 t2 · · · tn ∈ L(A) iff σ is a successful occurrence sequence of transitions of N . Therefore, L(G) = L(G )   where G = (V, Σ, S, R, L(A)) is a regularly controlled grammar. For each vector grammar, if we define an ordinary net as a union of disjoint pathes of the form ρ = t1 p1 t2 p2 · · · pn−1 tn for each matrix m = r1 r2 · · · rn where ti labeled with ri , 1 ≤ i ≤ n, then it is not difficult to see that an grammar controlled by this net generates the same language as the vector grammar. Lemma 14. V[λ] ⊆ MG[λ] (f, t) ∩ CN[λ] (f, t) ∩ GSM[λ] (f, t). For each semi-matrix grammar, if an ordinary net is defined as a union of disjoint cycles of the form ρ = p1 t1 p2 t2 · · · pn tn p1 for each matrix m = r1 r2 · · · rn where ti labeled with ri , 1 ≤ i ≤ n, then it is not difficult to see that an grammar controlled by this net generates the same language as the semi-matrix grammar. Lemma 15. sMAT[λ] ⊆ SM[λ] (f, t) ∩ MG[λ] (f, t).

336

J. Dassow and S. Turaev MATλ = PNλ (x, y) = Yλ (x, y) = Zλ (x, t)

PN(x, t) = X(x, t)

PN(x, r) = X(x, r)

PN(x, g) = X(x, g) MG(x, t) = GMG(x, t)

MG(x, r) = GMG(x, r)

GSM(x, t) MG(x, g) = GMG(x, g)

CN(x, t) GSM(x, r)

V

GSM(x, g)

SM(x, y) = MAT CN(x, r)

CN(x, g)

sMAT

CF

Fig. 4. The hierarchy of language families generated by Petri net controlled grammars

Now we summarize our results in the following theorem. Theorem 3. The relations in Figure 4 hold where x ∈ {f, −λ, λ}, y ∈ {r, g, t}, X ∈ {FC, EFC, AC, ON}, Y ∈ {SM, GSM, FC, EFC, AC, ON} and Z ∈ {MG, GMG, CN}; the lines (arrows) denote (proper) inclusions of the lower families into the upper families. Proof. The relations of the language families generated by sPN controlled grammars follow from Theorem 2. From Theorem 2.1.2 in [8], Theorem 12 in [9] and above presented lemmas we get sMAT ⊆ SM(x, y) = MAT ⊆ V ⊆ CN(x, t) ⊆ MG(x, t) = GMG(x, t) and V ⊆ GSM(x, t). The inclusion X(x, r) ⊆ X(x, t), X ∈ {FC, EFC, AC, ON}, follows from Theorem 13 in [1] and Lemma 8. Again from Theorem 13 in [1] we have PNλ (x, r) = MATλ ⊆ PNλ (x, t). If we define erasing matrices in the proof of Lemma 11 in [1] for each τ ∈ M as mτ = (B → λ, p¯1 → λ, . . . , p¯1 → λ, . . . , p¯n → λ, . . . , p¯n → λ)



 τ (p1 )

τ (pn )

Grammars Controlled by Special Petri Nets

337

where P = {p1 , p2 , . . . , pn }, then we also get PNλ (x, t) ⊆ MATλ . If we consider erasing matrices of the form mλ = (¯ p → λ) for each p ∈ P together with the matrices defined above then it is easy to see that PNλ (x, g) ⊆ MATλ . The equalities SMλ (x, y) = GSMλ (x, y) = MGλ (x, t) = GMGλ (x, t) = CNλ (x, t) = FCλ (x, y) = EFCλ (x, y) = ACλ (x, y) = ONλ (x, y) = PNλ (x, y) = MATλ follows from the fact that sMATλ = Vλ = MATλ (Theorem 2.1.2, [8] and Theorem 12, [9] and the above-presented lemmas).  

References 1. Dassow, J., Turaev, S.: Arbitrary petri net controlled grammars. In: Enguix, G., Jim´enez-L´ opez, M. (eds.) The Second International Workshop on Non-classical Formal Languages in Linguistics, Forling 2008, Tarragona, Spain, pp. 27–39 (2008) 2. Dassow, J.: Subregularly controlled derivations: Context-free case. Rostock. Math. Kolloq. 34, 61–70 (1988) 3. Dassow, J., Truthe, B.: Subregularly tree controlled grammars and languages. In: Csuhaj-Varj´ u, E., Esik, Z. (eds.) The 12th Inernational Conference AFL 2008, Balatonfured, Hungary, pp. 158–169 (2008) 4. Baumgarten, B.: Petri-Netze. Grundlagen und Anwendungen. Wissensschaftverlag, Mannheim (1990) 5. Desel, J., Esparsa, J.: Free-Choice Petri Nets. Cambridge Tracts in Theoretical Computer Science, vol. 10. Cambridge University Press, Cambridge (1995) 6. Rozenberg, G., Salomaa, A. (eds.): Handbook of Formal Languages, vol. I–III. Springer, Berlin (1996) 7. Reisig, W., Rozenberg, G. (eds.):Lectures on Petri Nets I: Basic Models. LNCS, vol. 1491. Springer, Heidelberg (1998) 8. Dassow, J., Pˇ aun, G.: Regulated Rewriting in Formal Language Theory. Springer, Berlin (1989) 9. Turaev, S.: Semi-matrix grammars. In: The Second Doctoral Workshop on Mathematical and Engineering Methods in Computer Science, MEMICS 2006, Mikulov, Czech Republic, pp. 245–252 (2006) 10. Graham, R., Lov´ asz, M.G. (eds.): Handbook of Combinatorics, vol. I–II. Elsevier(North-Holland), Amsterdam and MIT Press, Cambridge (1996)

Nested Counters in Bit-Parallel String Matching Kimmo Fredriksson1 and Szymon Grabowski2 1

2

Department of Computer Science, University of Kuopio, P.O. Box 1627, 70211 Kuopio, Finland [email protected] Computer Engineering Department, Technical University of L ´ od´z, Al. Politechniki 11, 90–924 L ´ od´z, Poland [email protected]

Abstract. Many algorithms, e.g. in the field of string matching, are based on handling many counters, which can be performed in parallel, even on a sequential machine, using bit-parallelism. The recently presented technique of nested counters (Matryoshka counters) [1] is to handle small counters most of the time, and refer to larger counters periodically, when the small counters may get full, to prevent overflow. In this work, we present several non-trivial applications of Matryoshka counters in string matching algorithms, improving their worst- or average-case time complexities. The set of problems comprises (δ, α)-matching, matching with k insertions, episode matching, and matching under Levenshtein distance.

1

Introduction

A word RAM is a random-access machine with unit-cost operations for operands of w bits, and having instruction set similar to modern computers. An especially practical variant of word RAM is transdichotomous RAM [2]. This model assumes that w = Ω(log(n)), where n is the “input size” (or simply w ≥ log2 (n); we also sometimes distinguish between a weaker assumption, that w = Θ(log(n)), and the more general case). Note that the word RAM model allows e.g. to sort n integers in o(n log n) time, which is impossible in the comparison model. Bit-parallelism [3] is now an established and highly successful algorithmic technique, useful especially in the field of string matching. Basically, it makes use of wide machine words (CPU registers) to parallelize the work of other algorithms, e.g., filling the matrix in a dynamic programming algorithm or simulating a non-deterministic automaton. Most interesting string matching problems can be classified as approximate string matching [4] of some sort. There is a plethora of approximate matching models, with applications in natural language processing, computational biology, music information retrieval, image processing and other areas. Many approximate matching problems can be stated like that. Given a text T = t0 . . . tn−1 , a pattern P = p0 . . . pm−1 , over some alphabet Σ, and a threshold k, we want to find all the text positions where the pattern matches the text with at most k errors. How the error measure is calculated constitutes the actual problem. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 338–349, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Nested Counters in Bit-Parallel String Matching

339

Bit-parallel solutions to approximate string matching problems often deal with counters. The counters are bit-fields storing the total errors for individual states of the problem, e.g., for every pattern prefix. Many such counters, each of size e.g. O(log(k)) bits, are updated in parallel, which makes the respective algorithms efficient in practice. In a recent work [1], we showed a simple technique to decrease the worstcase time complexity of one of the best known bit-parallel algorithms based on counters, Shift-Add [3], from O(nm log(k)/w) to O(nm/w). The underlying observation was that the counter values grow by at most one per read text character, hence most of the time the algorithm could update much smaller counters, and only when they can overflow, at periodical moments, their content could be added (and then flushed) to a high-level counters, occupying more bits. This idea was generalized to many counter levels, and dubbed Matryoshka counters, to reflect their nested nature. The current work presents several non-trivial applications of Matryoshka counters in string matching algorithms, improving their time complexities in the worst or average case.

2

Preliminaries

Let the pattern P = p0 p1 p2 . . . pm−1 and the text T = t0 t1 t2 . . . tn−1 be strings over alphabet Σ = {0, 1, . . . , σ − 1}. The pattern has an exact occurrence in some text position j, if pi = tj−m+1+i for i = 0 . . . m − 1. If pi = tj−m+1+i for at most k positions, then the pattern has an approximate occurrence with at most k mismatches. The number of mismatches is called Hamming distance. We want to report all text positions j where the Hamming distance is at most k. To present our algorithms, some extra notation is needed. We number the bits from the least significant (right-most) bit (0) to the most significant (leftmost) bit (w − 1). Bit-wise operations are denoted like in C language: & is bit-wise and, | is or, ∧ is xor, ∼ negates all bits, > are shift to left and to right, with zero padding. Exponentiation denotes bit repetition, as in (1(10)2 )2 = 1101011010. In general, all formulas of the above form will be (run-time) constants that can be precomputed. The notation V[i] denotes the ith -bit field of the bit-vector V . Shift-Add algorithm. To be able to describe our new algorithms we need to briefly cover some previous work. Shift-Add [3] is a bit-parallel algorithm for approximate searching under Hamming distance. It reserves a counter of  = log2 (k + 1) + 1 bits for each pattern character in a bit-vector D of length m bits. This bit-vector denotes the search state: the ith counter tells the number of mismatches for the pattern prefix p0 . . . pi for some text substring tj−i . . . tj . If the (m − 1)th counter is at most k at any time, i.e. D[m−1] ≤ k, then we know that the pattern occurs with at most k mismatches in the current text position j. The preprocessing algorithm builds an array B of bit-vectors. More precisely, we set B[c][i] = 0 iff pi = c, else 1. Then we can accumulate the mismatches as D ← (D ( − 1)) & (0−1 1)m ).

(1)

That is, we negate and select the highest bit of each counter (shifted to the low bit positions), and add the result to the original counters. If a counter value is

342

K. Fredriksson and S. Grabowski

...

1 2 3 4

if c < α + 1 then c ← c + 1 tmp ← input activated and tj ∈ [pi − δ, pi + δ] if c < α + 1 and tmp then activate output if tmp then c ← 0

...

Fig. 1. A building block for a systolic array detecting δ-matches with α-bounded gaps

less than α + 1, then the highest bit position is not activated, and hence the counter gets incremented by one. If the bit was activated, we effectively add 0. To detect the δ-matching characters we need to preprocess a table B, so that B[c] has ith bit set to 1, iff |pi − c| ≤ δ. We can then use a Shift-And step: tmp ← ((D > ( − 1)) & (0−1 1)m )

(3)

The only remaining difficulty to solve is how to reinitialize (parallelly) some subset of the counters to zero, i.e. how to implement line 4 in Fig. 1. The bitvector tmp has value 1 in every field position that survived the Shift-And step, i.e. in every field position that needs to be initialized in C. Then C ← (C & ∼(tmp × 1 )) | (tmp × (2−1 − (α + 1)))

(4)

first clears the corresponding counter fields, and then copies the initial value 2−1 − (α + 1) to all the cleared fields. This completes the algorithm. Clearly, it runs in O(nm log(α)/w) worst case time. 3.1

Two-Level Solution

Let us now improve this algorithm. We use the two-level variant. Basically,  = O(log log(α)) bits per counter is enough for the bottom level. However, the solution is somewhat more complicated than for the previous algorithm. The reason is that we need to know for each step of the algorithm if any of the counters have reached the value α + 1 or not, since this information is used to compute the next value of the counters at each step. I.e. it is not enough to detect  this for the last counter, which was easy. Again, we use  = log2 (α + 2 ) + 1, just as in the Shift-Add algorithm (now k is just called α). However, for the bottom level we add one additional bit per field. This new highest bit will be used to signal whether the corresponding counter has exceeded the value α + 1.  The two counter levels are added after each 2 −1 − 1 steps, so the highest bits of the bottom level counters never get activated if the counters started from zero.

Nested Counters in Bit-Parallel String Matching

343

The above base-line algorithm is used as is for the bottom level counters (we just replace  with  everywhere), with the following modification: the initial values copied to the counters are 0. The bottom and top level counters are denoted as C  and C, respectively. The first modification needed is handling the zeroing of the counters. If a bottom level counter gets zeroed, it should be done for the corresponding top level counter as well. But we cannot afford doing it in every step, since the cost would be too high. Instead, we introduce new bit-vector Z, which is initialized to all zeroes after each top level update. For each bottom level step we record the counters that should be zeroed for the top level as well: Z ← Z | tmp,

(5)

where tmp is as in Eq. (2). In other words, Z gets bit 1 to every “counter” field that is zeroed. This is then used in each top level step to clear the corresponding fields of the top level counter. This is done as in Eq. (4): Z ← Expand(Z) C ← (C & ∼((Z α+1 (the highest bit of the counter is set): the counter has overflowed.   −1 In this case we set C[i] , i.e. activate the overflow bit of the bottom  = 2 level counter.   2. C[i] ≤ α + 1 − (2 −1 − 1): the counter cannot overflow in the next 2 −1 − 1  steps, and we can safely set C[i]  to 0. 

3. α + 1 ≥ C[i] > α + 1 − (2 −1 − 1): the counter may or may not overflow in   the next 2 −1 − 1 steps. In other words, if the counter C[i]  has the value v, where v > α + 1 − C[i] , the sum of the two counters has overflowed. Let   v = α+1−C[i]. By the assumption of this case, v < 2 −1 . Let u = 2 −1 −v.  If the counter C[i] is initialized to u, the highest bit will be activated as soon as α-gap condition is violated. To keep the true sum of the counter levels correct, we also subtract u from the top level counter, i.e. set C[i] ← C[i] −u. The implementation of the cases 1 and 2 are easy. The case 2 is handled implicitly, i.e. all fields not touched by case 1 or 3 are left to zero. The first case is simple. The highest bits are extracted from C, and shifted to the  -th positions. The

344

K. Fredriksson and S. Grabowski

result can be contracted to fit into the bottom level counters, activating the corresponding highest bits: C  ← Contract((C & (10−1 )m ) >> ( −  )).

(9)

The case 3 is slightly trickier. First, those  bit fields of C that have not the highest bit set are selected, in vector x: o ← C & (10−1 )m

(10)

x ← C & ∼((o > ( − 1))).

(11)



We then add 2 −1 − 1 to every field of x, again select the highest bits of the result, signaling the fields that may reach α + 1, and form a new mask selecting these fields: 

y ← (x + (2 −1 − 1) × (0−1 1)m ) & (10−1 )m o ← (y > ( − 1))

(12) (13)

Then, the value of v can be computed as described above. Note that for C counters the value of zero is represented as 2−1 − (α + 1), which must be taken into account: v ← (((α + 1 + 2−1 − (α + 1)) × (0−1 1)m ) & o) − (C & o).

(14)

However, this simplifies to: v ← ((10−1 )m & o)−(C & o). Similarly, we compute the value for u (note that now zero is represented as 0): 

u ← ((2 −1 × (0−1 1)m ) & o) − v, 

(15)



which again simplifies to: u ← ((0− 10 −1 )m & o) − v. Finally, the values are subtracted from C, and added to C  , so that C + Expand(C  ) will be correctly maintained: C ←C −u C  ← C  | Contract(u)

(16) (17)

Following the Shift-Add analysis, it is easy to find the O(nm log log(α)/w) time complexity. Note that we can easily replace all the multiplications in the search code with precomputed masks and bitwise operations, and thus the analysis is valid even in AC0 RAM model (as detailed in [1] and Sec. 2, Expand() and Contract() can be implemented efficiently without multiplications).

4

Intrusion Detection and Episode Matching

A close relative to α-matching is searching allowing k insertions of symbols into the pattern. In other words, we want to find all minimal length text substrings t, such that id(P, t) ≤ k, where id(P, t) is the minimum number of symbols

Nested Counters in Bit-Parallel String Matching

345

inserted to P , to convert it to t. It follows that if P is a subsequence of t, then id(P, t) = |t| − |P | = |t| − m, and ∞ otherwise, and that m ≤ |t| ≤ m + k if t matches P with at most k insertions. This matching model has important applications in intrusion detection [9]. The problem can be solved using dynamic programming [9]. We define a vector C of counters: Ci = id(p0...i , th...j ), for i = 0 . . . m and some h. The initial values are C0 = 0, and Ci>0 = ∞. (The value ∞ can be represented as any value > k in practical implementation.) Therefore, the goal is to report all j such that Cm ≤ k. The computation of the new values of C, given the old values C o , is based on the following recurrence: o , if pi = tj , and Cio + 1 otherwise. Ci = Ci−1

(18)

The obvious implementation of the recurrence leads to O(mn) worst case time. It was then shown by Kuri et al. [9] how to compute Ci using bit-parallelism, which resulted in an O(nm log(k)/w) worst case time algorithm. We briefly present the Kuri et al. algorithm as this is the starting point of our solution. The Ci counters are packed into machine words. Only error counts up to k + 1 are interesting, so any Ci value above k could be replaced by k + 1, and a similar effect is achieved using overflow bits, a technique known from Shift-Add. In this way, the counters occupy  = log2 (k + 1) bits each. A table B storing σ bitvectors of length m( + 1) is built in the preprocessing. Each ( + 1)-bit field of B[c] is set to 01 if c = pi , and 0+1 otherwise. Note that the highest bit in each field is 0. Also the state vector D has m( + 1) bits, initialized to 0s. If the counters could use O(log(k)) bits, the update formula (invoked once per text character) could be simply Dnew = (B[tj ] & (D > j) & 1) − ((Vi− >> j) & 1).

(20)

However, the values of Ci,j can grow large, and cannot (all) be efficiently maintained explicitly. Still, one of the key ingredients of ABNDM boils down to detecting as soon as possible the situation when all the values in Ci have exceeded k. The solution presented in [13] uses bit-parallel witnesses. A witness is some explicitly maintained value of Ci , needing only  = O(log(m)) bits. Hence a single

348

K. Fredriksson and S. Grabowski

bit-vector of w bits can pack O(w/ log(m)) witnesses. These are distributed uniformly, i.e. every -th value of Ci is explicitly maintained (and Ci,m is always maintained). The values can be easily updated in parallel, by masking the V + and V − vectors appropriately. The particularities of the problem guarantee that: 1. No value can be negative. 2. If all values of Ci have reached a certain threshold, then they cannot anymore be decreased below that threshold, i.e. every value of Ci+1 is at least that threshold. 3. The values of two neighboring witnesses can differ by at most /2 ; The two last properties can be used to bound the actual values of Ci : if all witnesses have exceeded k + /2 , then all values of Ci have surely exceeded k. The first two properties can be used to obtain efficient bit-parallel algorithm, also in our case. From the analysis point of view, this is effectively the same as searching with k  = k + O() errors, and the time bound becomes O(n(k + log(m) + logσ (m))/m), for m = O(w). The O(log(m)) term can be relaxed by using more witnesses, and we can afford using more witnesses by using more counter levels. The solution is similar to that of used for (δ, α)-matching. The main difference is that the counter (witness) values can also decrease. Let us again consider the two level counter splitting. For the bottom level we use  = Θ(log log(m)) bits per counter, and hence w/ witnesses. Obviously, the top level needs  = Θ(log(m)) bits per counter, and Θ(w/ ) in total. More precisely, we use  = log(log(m + 1) + 1) + 2 bits  per counter in the bottom level, and  = log2 (m + 2 −1 ) + 1 for the top level. We note that these could be improved a bit (see the formulas in [13]), but not  asymptotically. Consider a bottom level (witness) counter W[i]  and a top level   counter W[i] . Call k = k +  /2 . Then we can proceed as follows:  1. Initialize W[i]  to 0. This is safe at first, since no counter can have a negative value. Initialize W[i] to 2−1 − (k  + 1), which is used to represent 0.  −2 −1 2. Bottom level phase: update the counter W[i]  . This is repeated 2  times. Check if the highest bit of W[i] is activated, for all i. If so, terminate the text window scan.   −2 3. Top level phase: Compute x = W[i] −1). If x > 0, add x to W[i] , and  −(2 

  −2 subtract x from W[i] − 1). Otherwise, do nothing.  (i.e. initialize it to 2 This ensures that the counter cannot underflow (nor overflow) in the next bottom level phase.  4. Adjust W[i]  and W[i] , as described shortly. 5. Go to step 2.

The above scheme correctly maintains the counter values, taking care no underflow or overflow can happen. However, in step 2 we check the highest bits of the bottom level counters, but these never get activated (as step 3 prevents that), unless step 4 adjusts the values appropriately. Step 4 is similar to the cases 1–3 in Sec. 3.1, i.e. the bottom level counters are initialized differently, if the sum of

Nested Counters in Bit-Parallel String Matching

349



the two counter levels have exceeded k  , or are 2 −2 − 1 steps away from doing so. The technique is precisely the same as before. Note that even if the highest   −2 bit of W[i] − 1 steps.  is activated, the counter still cannot overflow in 2 Given the tools we have developed, all the steps can be easily performed bitparallelly. The actual implementation is similar to that of (δ, α)-matching, hence we do not give the details. The analysis is the same as for the original algorithm, the only difference is that the threshold k  is now k +  /2 , instead of k + /2 . Hence the algorithm runs in O(n(k + log log(m) + logσ (m))/m) average time for m = O(w).

Acknowledgments We thank an anonymous referee for insightful comments helping to improve the original paper version.

References 1. Grabowski, S., Fredriksson, K.: Bit-parallel string matching under Hamming distance in O(nm/w) worst case time. IPL 105(5), 182–187 (2008) 2. Pˇ atra¸scu, M.: Predecessor search. In: Kao, M.Y. (ed.) Encyclopedia of Algorithms. Springer, Heidelberg (2008) 3. Baeza-Yates, R.A., Gonnet, G.H.: A new approach to text searching. Communications of the ACM 35(10), 74–82 (1992) 4. Navarro, G.: A guided tour to approximate string matching. ACM Computing Surveys 33(1), 31–88 (2001) 5. Fredman, M.L., Willard, D.E.: Surpassing the information theoretic bound with fusion trees. J. Comput. System Sci. 47, 424–436 (1993) 6. Fredriksson, K., Grabowski, S.: Efficient algorithms for pattern matching with general gaps, character classes and transposition invariance. Information Retrieval 11(4), 335–357 (2008) 7. Navarro, G., Raffinot, M.: Flexible Pattern Matching in Strings – Practical online search algorithms for texts and biological sequences, 280 pages. Cambridge University Press, Cambridge (2002) 8. Fredriksson, K., Grabowski, S.: Efficient bit-parallel algorithms for (δ, α)-matching. ` In: Alvarez, C., Serna, M. (eds.) WEA 2006. LNCS, vol. 4007, pp. 170–181. Springer, Heidelberg (2006) 9. Kuri, J., Navarro, G., M´e, L.: Fast multipattern search algorithms for intrusion detection. Fundamenta Informaticae 56(1–2), 23–49 (2003) 10. Landau, G.M., Vishkin, U.: Efficient string matching with k mismatches. Theoretical Computer Science 43(2-3), 239–249 (1986) 11. Das, G., Fleischer, R., G¸asieniec, L., Gunopulos, D., K¨ arkk¨ ainen, J.: G¸asieniec, L., Gunopulos, D., K¨ arkk¨ ainen, J.: Episode matching. In: Hein, J., Apostolico, A. (eds.) CPM 1997. LNCS, vol. 1264, pp. 12–27. Springer, Heidelberg (1997) 12. Chang, W., Marr, T.: Approximate string matching with local similarity. In: Crochemore, M., Gusfield, D. (eds.) CPM 1994. LNCS, vol. 807, pp. 259–273. Springer, Heidelberg (1994) 13. Hyyr¨ o, H., Navarro, G.: Bit-parallel witnesses and their applications to approximate string matching. Algorithmica 41(3), 203–231 (2005) 14. Myers, G.: A fast bit-vector algorithm for approximate string matching based on dynamic programming. Journal of the ACM 46(3), 395–415 (1999)

Bounded Delay and Concurrency for Earliest Query Answering Olivier Gauwin1,2,3 , Joachim Niehren1,3 , and Sophie Tison2,3 1

INRIA, Lille University of Lille 1 Mostrare project, INRIA & LIFL (CNRS UMR8022) 2

3

Abstract. Earliest query answering is needed for streaming XML processing with optimal memory management. We study the feasibility of earliest query answering for node selection queries. Tractable queries are distinguished by a bounded number of concurrently alive answer candidates at every time point, and a bounded delay for node selection. We show that both properties are decidable in polynomial time for queries defined by deterministic automata for unranked trees. Our results are obtained by reduction to the bounded valuedness problem for recognizable relations between unranked trees.

1

Introduction

Streaming algorithms are relevant for XML databases and data exchange, whenever large data collections that cannot be stored in main memory are to be processed. Instead data is communicated over streams and processed incrementally. Recently, XML streaming algorithms were proposed for schema validation [1] (membership in tree languages), one-pass typing [2] (annotating nodes of trees by types), and query answering [3,4,5]. The space complexity of streaming algorithms for answering node selection queries in XML trees depends on the size of the call stack (bounded by the depth of the tree) and on the number of concurrently alive answer candidates that are kept in main memory at every time point [6]. The purpose of earliest query answering (EQA) is to minimize the second number. Selection and unselection of answer candidates need to be decided as early as possible, so that selected candidates can be output and unselected candidates discarded as early as possible. In both cases they are removed from main memory. EQA is the objective of various streaming algorithms for Forward XPath and its fragments [6,7,8], and has been studied for automata defined queries too [9,10]. In the latter paper, it is shown how to obtain a correct EQA algorithm for a fragment of Forward XPath under schema assumptions, by a P-time translation to deterministic streaming tree automata (dSTAs) [11], or equivalently deterministic nested word [12], visibly pushdown [13] or pushdown forest automata [14]. Whether EQA is tractable depends on two properties of the considered query Q and schema S, both of which are independent of the concrete algorithm. The first restriction is bounded delay of selection, which requires a bound for all trees t ∈ S on the number of events between the first visit of a selected node π ∈ Q(t) A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 350–361, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Bounded Delay and Concurrency for Earliest Query Answering

351

and the earliest event that permits its selection. This limits the waiting time for the answer. The second restriction is bounded concurrency of alive candidates, which imposes a bound on the number of concurrently alive answer candidates for Q wrt. S for all trees of S at all time points. This limits the maximal number of candidates that need to be memoized simultaneously by every EQA algorithm. In this paper, we show that bounded delay and bounded concurrency are decidable in P-time for n-ary queries and schemas defined by deterministic automata for unranked trees. Our result holds for dSTAs, as well as for bottomup deterministic tree automata that operate on binary encodings of unranked trees [15], either firstchild-nextsibling based or Curried [16]. When restricting databases to words instead of trees, decision procedures for bounded delay and concurrency for queries defined by dFAs can be obtained quite easily by reduction to bounded ambiguity of nFAs. The algorithm for words, however, cannot be lifted to trees in any straightforward manner. In order to solve this problem, we propose another solution by reduction to the bounded valuedness problem of recognizable relations between unranked trees. As we show, this problem can be reduced to bounded valuedness of bottom-up tree transducers, which can be decided in P-time (Theorem 2.8 of [17]). All reductions are in P-time since we start from deterministic automata. Omitted proofs can be found in the long version.

2

Queries in Words

We recall definitions of schemas and queries for tuples of positions in words by dFAs, and the concept of bounded ambiguity for nFAs. Words, Positions, and Events. Let an alphabet Σ be a finite set with elements ranged over by a, b, c and N the set of natural numbers n ≥ 1. We will consider words w ∈ Σ + as databases. The set of all words Σ ∗ is closed under concatenation ww and contains the empty word . The set of positions of a word w ∈ Σ ∗ is pos(w) = {1, . . . , |w|} where |w| is the number of letters of w. For all w ∈ Σ + and positions π ∈ pos(w) we define lab w (π) ∈ Σ to be the π-th letter of word w and say that position π is labeled by lab w (π). One-way finite automata process words letter by letter from the left to the right, equally to streaming algorithms for words. We define the set of events for a word w ∈ Σ + by adding the start event 0 to the set of all positions eve(w) = {0} ∪ pos(w). For all events e ∈ eve(w), we define w≤e ∈ Σ ∗ to be the prefix of w with exactly e letters. We say that two words coincide until event e if w≤e = w≤e and write eq e (w, w ) in this case. Queries and Schemas. An n-ary query Q selects a set of n-tuples of positions for every word w ∈ Σ + . It is a function which maps words w to sets of tuples of positions Q(w) ⊆ pos(w)n . A schema S ⊆ Σ + restricts the set of permitted databases. We say that a word w ∈ Σ + satisfies a schema S if and only if w ∈ S. Automata, Ambiguity, and Determinism. A finite automaton (nFA) over Σ is a tuple A = (stat, init , rul , fin) where init , fin ⊆ stat are finite sets and a  rul ⊆ stat 2 × (Σ ∪ {}) contains rules that we write as q → q  or q → q 

352

O. Gauwin, J. Niehren, and S. Tison

where q, q  ∈ stat and a ∈ Σ. Whenever necessary, we will index the components of A by A. Let the size of A count all states and rules, i.e., |A| = |stat A | + |rul A |. A run of A on a word w is a function r : eve(w) → stat A so that r(0) ∈ init A ∗ a ∗ and r(π−1) → → → r(π) is justified by rul for all π ∈ pos(w) with a = lab w (π). A run is successful if r(|w|) ∈ fin A . The language L(A) ⊆ Σ ∗ is the set of all words that permit a successful run by A. An nFA is called productive, if all its states are used in some successful run. This is the case if all states are reachable from some initial state, and if for all states, some final state can be reached. The ambiguity amb A (w) is the number of successful runs of A on w. The ambiguity of A is k-bounded if amb A (w) ≤ k for all w ∈ Σ ∗ . It is bounded, if it is bounded by some k. An nFA is deterministic or a dFA if it has at most one initial state and at most one rule for all left hand sides, including letters. Clearly the ambiguity of dFAs is 1-bounded. Stearns and Hunt [18] present a P-time algorithm for deciding k-bounded w ambiguity of nFAs. Let us write p → q by A if there exists a run of A[init = {p}] (the automaton obtained from A by setting its initial states to {p}) on w that ends in q. Weber and Seidl [19] show that an nFA A has unbounded ambiguity w w iff there exists a word w ∈ Σ + and distinct states p = q such that p → p, p → q, w q → q by A. This can be tested in O(|A|3 ) as shown very recently by [20]. Canonicity and Types. Let B = {0, 1} be the set of Booleans. For words w ∈ Σ ∗ and tuples τ = (π1 , . . . , πn ) ∈ pos(w)n , let w ∗ τ be the annotated word in (Σ × Bn )∗ obtained from w by relabeling all positions π ∈ pos(w) to (lab w (π), b1 , . . . , bn ), where bi = 1 if π = πi and bi = 0 otherwise. The canonical language of an n-ary query Q is can Q = {w ∗ τ | τ∈ Q(w)}. The type of a word v ∈ (Bn )∗ is an element of (N ∪ {0})n defined by π∈pos(v) lab v (π). The type of a word in (Σ × Bn )∗ is the type of its projection in (Bn )∗ . All words over Σ × Bn of type 1n have the form w ∗ τ , and vice versa. An nFA A over Σ × Bn is called canonical if all words of L(A) have type 1n . For productive canonical dFAs A, every state q ∈ stat has a unique type in Bn , which is the type of all words with runs by A ending in q (e.g., Lemma 3 of [21]).

3

Earliest Query Answering for Words

We recall the framework of EQA for XML databases from [10], but restricted to the case of words, and show for queries defined by dFAs that bounded concurrency and delay can be reduced in P-time to bounded ambiguity for dFAs. An EQA algorithm decides selection and failure of answer candidates at every time point (without knowing the rest of the stream). This way, it needs to keep in main memory only alive candidates, which are neither safe for selection nor failure. As an example, consider the monadic query Q that selects all positions in words w that are labeled by a and followed by bb. When applied to w = aabbabbcabab, this query returns Q(w) = {(2), (5)}. A streaming algorithm can enumerate these answers by using a sliding window of length 3. Position 1 for instance can be refused when having seen the labels of positions 1, 2, while position 2 can be selected when having seen the labels of positions 2, 3, 4.

Bounded Delay and Concurrency for Earliest Query Answering

353

Schema assumptions are relevant to EQA since restricting the remainder of the stream. The schema (a|b)∗ c(ab)∗ , for instance, excludes all positions from Q(w) that are on the right of the c letter in w. This allows to exclude positions 8, . . . , 12 to belong to the answer set Q(w) immediately at the respective position. Earliest Selection and Bounded Delay. The delay of a selected position is the number of subsequent events before selection can be safely decided. More formally, let Q be an n-ary query in words w ∈ Σ + satisfying a schema S ⊆ Σ + . We define a relation sel SQ (w) that links tuples τ ∈ pos(w)n to events e ∈ eve(w) that are sufficient for selection, i.e., where τ will be selected in all possible continuations of the stream beyond e. Only those continuations are allowed, which extend the current prefix of the word to a member of S: (τ, e) ∈ sel SQ (w) ⇔ τ ∈ {1, . . . , e}n ∧ ∀w ∈ S. eq e (w, w ) ⇒ τ ∈ Q(w ) Note that the initial event 0 may be sufficient to select the empty tuple () in Boolean queries where n = 0, while it is never sufficient for selection if n ≥ 1 since otherwise τ ∈ {1, . . . , e}n . Let latest((π1 , . . . , πn )) = max1≤i≤n πi be the latest position of the tuple. The delay of an n-ary query Q for a tuple τ ∈ pos(w) is the number of events e following latest(τ ) such that e is insufficient for selection, i.e., (τ, e) ∈ sel SQ (w). delay SQ (w, τ ) = |{e ∈ eve(w) | latest(τ ) ≤ e, (τ, e) ∈ sel SQ (w)}| Query Q with schema S has k-bounded delay if delay SQ (w, τ ) ≤ k for all w ∈ S and τ ∈ Q(w). It has bounded delay if it has k-bounded delay for some k ≥ 0. Having bounded delay means that every EQA algorithm will output selected tuples a constant time after completion. Deciding Bounded Delay. We start with the case without schemas. Let A be a canonical and productive dFA over Σ × Bn and QA the n-ary query that it defines. We call a state q ∈ stat A of type 1n safe for selection if (Σ × {0}n )∗ ⊆ L(A[init = {q}]). Since A is canonical and deterministic, this is the case if and only if all states reachable from q are final and have outgoing transitions for all letters in Σ × {0}n. Thus, the set of states of A that are safe for selection can be computed in time O(|A| + |Σ| + n). Lemma 1. If the run r of a canonical dFA A on w ∗ τ exists then it satisfies for all e ∈ pos(w) that r(e) is safe for selection if and only if (τ, e) ∈ selQA (w). We define an nFA D(A) such that amb D(A) (w ∗ τ ) = delay QA (w, τ ) for all τ ∈ QA (w). D(A) has the same states as A except for one additional state ok, which is the only final state of D(A). All transitions of A are preserved by D(A). In addition to simulating A, automaton D(A) has  transitions into the state ok from all states q of type 1n of A that are unsafe for selection. State ok has transitions into itself for all letters in Σ × {0}n. Proposition 1. For w ∈ Σ ∗ , τ ∈ QA (w): delayQA (w, τ ) = ambD(A) (w ∗ τ ). Proof. Consider a run of D(A) on a canonical word w ∗ τ . The only ambiguity of D(A) is introduced by the -transitions, by which to exit from A at positions

354

O. Gauwin, J. Niehren, and S. Tison

between the last component of τ (included) and the earliest event that is safe for the selection of τ . The number of such positions is precisely delay QA (w, τ ). Theorem 1. Bounded delay for queries QA and schemas L(B) defined by dFAs A, B can be decided in time O(|A| · |B|), and k-bounded delay in P-time. Proof. We sketch the proof for bounded delay without schemas, where L(B) = Σ ∗ . By Proposition 1, it is sufficient to decide whether D(A) has bounded ambiguity. By Weber and Seidl’s characterization, this holds if the subautomaton of A containing only unsafe states for selection of type 1n , has no loop. Acyclicity of this subautomaton can be tested in time O(|A|). Earliest Failure and Bounded Concurrency. The space complexity of EQA algorithms depends on the concurrency of a query, which is the maximal number of concurrently alive answer candidates at every time point [6,7], since these are to be kept in main memory. In order to formalize this for n-ary queries, we have to deal with partial answer candidates for a given word w. We fix a constant • that represents unknown components, and define partial tuples τ of positions until e ∈ pos(w) as members of ({1, . . . , e}  {•})n . So far, we have only studied complete answer candidates, which do not contain any unknown component. We write compl (τ, w, e) for the set of complete candidates, in which all unknown components of τ have been instantiated with nodes π ∈ pos(w) such that e ≤ π. Given a query Q, schema S, and word w ∈ S, we call a partial candidate τ failed at event e ∈ eve(w), if no completion of τ by nodes in the future of e is selected by Q.  τ ∈ ({1, . . . , e}  {•})n ∧ S (τ, e) ∈ fail Q (w) ⇔ ∀w ∈ S. eq e (w, w ) ⇒ ∀τ  ∈ compl (τ, w , e). τ  ∈ / Q(w ) A partial candidate τ ∈ ({1, . . . , e} ∪ {•})n is alive at e if it is neither failed nor selected at e. The concurrency of a query schema pair on a word w ∈ Σ + at position e ∈ eve(w) is the number of alive candidates at time point e, so that e is neither sufficient for selection or failure: (τ, e) ∈ alive SQ (w) ⇔ (τ, e) ∈ fail SQ (w) and (τ, e) ∈ sel SQ (w) concur SQ (w, e) = |{τ ∈ ({1, . . . , e} ∪ {•})n | (τ, e) ∈ alive SQ (w)}| We say that the concurrency of a query schema pair is bounded if there exists k ≥ 0 such that concur SQ (w, e) ≤ k for all words w ∈ S and e ∈ pos(w). Deciding Bounded Concurrency. We start with queries without schemas. So let A be a canonical productive dFA over Σ ×Bn and QA the query it defines. Recall that all states of A have a unique type v ∈ Bn . We call a state q of type v safe for failure, if no final states can be reached from q by words of complementary type 1n − v. By canonicity, this is the case if no final states can be reached from q at all. We can thus compute the set of safe states for failure in time O(|A|). Lemma 2. If the unique run r of a canonical dFA A on some w ∗ τ exists, then all e ∈ pos(w) satisfy that r(e) is safe for failure if and only if (τ, e) ∈ failQA (w). We define an nFA C(A) such that amb C(A) (w ∗ e) = concur Q (w, e) for all e ∈ pos(w). The situation is a little different than for D(A) since C(A) runs on words

Bounded Delay and Concurrency for Earliest Query Answering

355

annotated by events rather than tuples. So the alphabet of C(A) is Σ × B. The nFA C(A) guesses all partial candidates with positions until e, tests whether they are alive at e, and accepts in this case and only this case. Proposition 2. For all e ∈ pos(w): concurQA (w, e) = ambC(A) (w ∗ e). Theorem 2. Bounded and k-bounded concurrency for queries and schemas defined by canonical dFAs can be decided in P-time for any fixed k ≥ 0.

4

Earliest Query Answering for Unranked Trees

We extend EQA from words to unranked trees. We then lift our P-time decision results to tree automata for unranked trees, and argue why the proofs for words cannot be lifted in any straightforward manner. The set of unranked trees TΣ is the least set that contains all (k+1)-tuples a(t1 , . . . , tk ) where k ≥ 0, a ∈ Σ and t1 , . . . , tk ∈ TΣ . Positions of words correspond to nodes of trees, defined by nod (a(t1 , . . . , tk )) = {} ∪ {iπ | π ∈ nod (ti )}. The word w = abaca, for instance, can be encoded by the tree t = r(a, b, a, c, a), where r ∈ Σ is an arbitrary symbol. Note that nod (t) = {} ∪ pos(w). Queries Q in unranked trees select tuples of nodes Q(t) ⊆ nod (t)n for all trees t ∈ TΣ . Events are produced by preorder traversals: eve(t) = {start} ∪ ({open, close} × nod (t)) There is an initial event start and an opening and a closing event per node. Let ≤ be the total order on eve(t) induced by preorder traversals over trees t ∈ TΣ , and let pred(e) be the immediate predecessor of event e ∈ eve(t) − {start}. For all e ∈ eve(t) − {start}, we define the prefix t≤e of t to be the tree which contains the part of t with all nodes opened before e, i.e., nod (t≤e ) = {π ∈ ≤e nod (t) | (open, π) ≤ e}, and lab t (π) = lab t (π) for all π ∈ nod (t≤e ). Note that t≤(close,π) contains all proper descendants of π in t, while t≤(open,π) does not. As before, we can define eq e (t, t ) by e = start or t≤e = t≤e . The notion t ∗ τ ∈ TΣ×Bn extends straightforwardly from words to trees. The canonical language of an n-ary query Q thus has type can Q ⊆ TΣ×Bn . The definitions of sel SQ , fail SQ , delay SQ and concur SQ extend literally, except that the set {1, . . . , e} needs to be replaced by nod (t≤e ). Tree automata for unranked trees are often obtained from standard tree automata for binary trees. A binary signature is a finite set Γ = Γ2  Γ0 with constants in Γ0 and binary function symbols in Γ2 . The set of binary trees TΓbin is the least set containing all c ∈ Γ0 and triples f (t1 , t2 ) where f ∈ Γ2 and t1 , t2 ∈ TΓbin . A tree automaton (TA) for binary trees in TΓbin is a tuple A = (stat , fin, rul) consisting of finite sets fin ⊆ stat and a set rul ⊆ ∪i∈{0,2} stat i+1 ×Γi , that we denote as f (q1 , q2 ) → q and c → q where q1 , q2 , q ∈ stat, f ∈ Γ2 and c ∈ Γ0 . A run of A on t ∈ TΓbin is a function r : nod (t) → stat such that f (r(π1), r(π2)) → r(π) belongs to rul A for all nodes π of t with lab t (π) = f ∈ Γ2 , and r(π) → c in rul A for all nodes π of t with lab t (π) = c ∈ Γ0 . The language Lbin (A) is the set

356

O. Gauwin, J. Niehren, and S. Tison a

b

c

a d e

fcns

b

⇒

⊥ c

⊥ ⊥

a

d e

⊥ Fig. 1. Binary encoding

⊥ ⊥

d

b

c



e = f

(a, d) (b, e)

(c, ⊥)

(⊥, f )

Fig. 2. Example for overlays

of all binary trees over Γ that permit a successful run by A, where r() ∈ fin. A (bottom-up) deterministic TA (dTA) is a TA of which no two rules have the same left hand side. We can encode unranked trees t ∈ TΣ into binary trees by applying Rabin’s where Σ⊥ = Σ  {⊥}. The firstchild-nextsibling encoding fcns : TΣ → TΣbin ⊥ definition is recalled by example in Fig. 1. A TA over TΣ⊥ defines the language of unranked trees L(A) = {t ∈ TΣ | fcns(t) ∈ Lbin (A)}. Operationally, however, dTAs fail to operate in streaming manner on unranked trees, so that the previous decision algorithms cannot be lifted to queries defined by dTAs. Streaming tree automata (STAs) [11] operate in the proper order. They are a reformulation of nested word automata [12,13] and shown equivalent to pushdown forest automata [14]. Deterministic STAs (dSTAs) can perform one-pass typing for extended DTDs with restrained competition [2] as well as EQA [10] for queries defined by dSTAs. Furthermore, deterministic stepwise tree automata [16] can be converted in dSTAs in linear time. Proposition 3 (Closure properties). The classes of TAs (wrt. the fcns encoding) and STAs permit determinization, and recognize the same languages of unranked trees modulo P-time automata translations (not preserving determinism). Recognizable languages are closed under Boolean operations, projection and cylindrification. All corresponding operations on TAs (resp. STAs) can be performed in P-time and preserve determinism except for projection. Even with STAs, it remains difficult to lift our P-time algorithms for words to trees, since the notion of safe states becomes more complex. Given a canonical dSTA A for query QA , one can define another dSTA E(A) for which appropriate notions of safe states wrt. QA exist [10]. The size of E(A), however, may grow exponentially in |A|. Therefore, we cannot use E(A) to construct polynomially sized counterparts of D(A) and C(A) in the case of unranked trees. Nevertheless: Theorem 3 (Main). Bounded delay is decidable in P-time for n-ary queries and schemas in unranked trees defined by dTAs (wrt. the fcns or Curried encoding) or dSTAs, where n may be variable. Bounded concurrency is decidable in P-time for fixed n. For fixed k and n, k-bounded delay and concurrency are decidable in NP-time.

Bounded Delay and Concurrency for Earliest Query Answering a a

a

0

a

a

close

b

b

a

0

(a) Tree t

(b) Tree s

b

357

0 0

(c) Tree se

0

open

0 (d) Tree se

Fig. 3. (t, s, se ) ∈ Eq but (t, s, se ) ∈ / Eq

Our proof will be based on the powerful notion of recognizable relations between unranked trees (see [15] for ranked trees). Bounded delay and concurrency are reduced to bounded valuedness of recognizable relations, which in turn is reduced to bounded valuedness of tree transducers for binary trees [17].

5

Recognizable Relations between Unranked Trees

We extend the theory of recognizable relations from ranked to unranked trees. We show that FO-formulas over recognizable relations with n free variables define recognizable relations between n unranked trees (so that satisfiability is decidable), and that bounded valuedness of recognizable relations can be decided in P-time by reduction to bounded valuedness of tree transducers (for binary trees). Recognizable Relations. In this section, we assume an arbitrary class of tree automata, that satisfy the properties of STAs in Proposition 3. This includes TAs modulo the fcns encoding, STAs, and stepwise tree automata [16] (but not deterministic hedge automata with dFAs for horizontal languages [15]). The overlay of k unranked trees ti ∈ TΣ i is the unranked tree t1  . . .  tk in TΣ⊥ 1 ×...×Σ k obtained by superposing these k trees top-down and left-to-right; ⊥ the ⊥ symbol represent missing children where the structures of the trees differ. This is illustrated in Fig. 2. Overlays of ranked trees can be obtained this way too [15], except that overlayed symbols need to inherit the maximal arity. A k-ary relation R between unranked trees is recognizable iff the language of its overlays ovl(R) = {t1  . . .  tk | (t1 , . . . , tk ) ∈ R} is recognizable by a tree automaton. We say that R is recognized by the automaton A if ovl(R) = L(A). We also say that R can be computed in time k if an automaton recognizing R can be computed in time k. The prime example is the relation Eq ⊆ TΣ × TΣ × T{0,open,close} . Here, we map event e = (α, π) ∈ eve(t) to trees rene (t) ∈ T{0,open,close} obtained by relabeling t, such that π is relabeled to α and all other nodes to 0. We then define Eq = {(t, s, rene (t)) | eq e (t, s)}. See Fig. 3 for an example. Lemma 3. Given a signature Σ, a deterministic automaton recognizing relation Eq ⊆ TΣ × TΣ × T{0,open,close} can be computed in time O(|Σ|2 ). An STA recognizing ovl(Eq ) with O(1) states is easy to define. It can be converted into a TA by Proposition 3 and from there to a deterministic automaton of the class under consideration by assumption. The resulting automaton still has O(1) states, and thus an overall size of O(|Σ|), if we assume in addition a function ψ such that |A| ≤ |Σ| · ψ(|stat A |) for all automata A with signature Σ.

358

O. Gauwin, J. Niehren, and S. Tison

FO Logic. Let Ω be a collection of unranked disjoint signatures and  a set of recognizable relations between unranked trees, so that each relation R ∈  has R a type R ⊆ TΣ1R × . . . × TΣ R where Σ1R , . . . , Σar(R) ∈ Ω and ar(R) ≥ 0. We ar(R) fix an infinite set of variables V ranging over unranked trees. A FO formula over recognizable relations in  and signatures in Ω has the abstract syntax: φ ::= R(X1 , . . . , Xar(R) ) | φ ∧ φ | ¬φ | ∃X∈TΣ . φ where R ∈ , X1 , . . . , Xar(R) ∈ V , and Σ ∈ Ω. We assume that all formulas are well-typed, i.e., that the types of variables are compatible with those of the relations in which they appear. A formula φ with m free variables X1 , . . . , Xm of types TΣ1 , . . . , TΣm defines an m-ary relation Rφ(X1 ,...,Xm ) ⊆ TΣ1 × . . . × TΣm . The closure properties of tree automata ensure that all such relations are recognizable. Let FO ∃ [] be the set of formulas where existential quantifiers are restricted to occur outermost (and Ω is the set of signatures appearing in the types of relations in ). The size |φ| is the number of nodes of φ. Proposition 4. Let  be a finite set of relations recognized by deterministic automata {AR }R∈ . Then there exists a polynomial p such that for all formulas φ in FO∃ [], an automaton recognizing the relation defined by φ can be computed in time p(|φ|, (|AR |)R∈ ). Bounded Valuedness. Let R ⊆ TΣ1 × TΣ2 be a recognizable binary relation. For every s1 ∈ TΣ1 , the number #R(s1 ) = |{s2 | (s1 , s2 ) ∈ R}| counts the trees in TΣ2 in relation to it. The valuedness of R is the maximal such number val (R) = maxs∈TΣ1 #R(s). We call R bounded if val (R) ≤ k for some k ≥ 0. Lemma 4. A relation R between unranked trees is recognizable iff the corresponding relation between binary trees fcns(R) is, and val(fcns(R)) = val(R). Theorem 4. For every automaton A recognizing a binary relation R between unranked trees, i.e., L(A) = ovl(R): 1. val(R) < ∞ can be decided in P-time in |A|. 2. val(R) < k (for a fixed k) can be decided in NP-time in |A|. Proof. It is sufficient to prove the theorem for TAs over binary trees by Lemma 4. We start with recognizable relabeling relations, and lift the result to recognizable relations in the long version of the paper. A relabeling relation R ⊆ TΣ 1 × . . . × TΣ n is a relation between trees of the same structure, i.e., whenever (s1 , . . . , sn ) ∈ R then nod (s1 ) = . . . = nod (sn ). In other words, the overlays in ovl(R) do not contain any place holder ⊥. So let R ⊆ TΣ × TΔ be a relabeling relation for binary signatures, and A a TA for trees in TΣ×Δ that recognizes R, i.e., Lbin (A) = ovl(R). We transform A into a bottom-up tree transducer T for defining the relation R as in [22]. The rules of T are infered as follows where x1 , x2 are variables: (f, g)(p1 , p2 ) → p ∈ rul(A) f (p1 (x1 ), p2 (x2 )) → p(g(x1 , x2 )) ∈ rul (T )

(a, b) → p ∈ rul(A) a → p(b) ∈ rul(T )

Bounded Delay and Concurrency for Earliest Query Answering

359

This transducer T has the same valuedness as R. Theorem 2.8 of [22] shows that it can be decided in polynomial time whether T is finite-valued, i.e., whether R is bounded. Concerning k-valuedness, it can be decided in non-deterministic polynomial time according to Theorem 2.2 of [22]. The polynomials for testing bounded valuedness of tree transducers are much higher than for testing bounded ambiguity for tree automata [23]. Using the above constructions and Theorem 2.7 of [22], we can build an algorithm for computing the exact value of val (R), if it exists. We can proceed by P (|A|) , for a fixed polynomial P . dichotomy, starting from 22 From Proposition 4, we get in P-time a non-deterministic automaton recognizing a relation defined by an FO ∃ [] formula, and then apply Theorem 4: Corollary 1. Let  be a finite set of relations and AR deterministic automata recognizing R ∈ . Then there exists a polynomial p such that for formulas φ in FO∃ [], the bounded valuedness val(Rφ ) < ∞ of the relation Rφ defined by φ can be decided in time p(|φ|, (|AR |)R∈ ).

6

Deciding Bounded Delay and Concurrency

We prove the main Theorem 3 on deciding bounded delay and concurrency by reduction to Corollary 1 on recognizable relations. Let Q be an n-ary query for trees in TΣ and S ⊆ TΣ a schema. We define a relation CanQ = {(t, ren τ (s)) | t ∗ τ ∈ can Q ∧ Eq(t, s, ren latest(τ ) (t))}, where ren τ (s) is the projection of s ∗ τ to Bn . The relation Bef = {(t, ren τ (t), ren e (t)) | τ ∈ nod (t≤e )n } is recognizable by a dTA of size O(2n ), so we cannot use this relation for P-time algorithms without fixing n. By using the relation Bef&Can Q = {(t, sτ , se ) | CanQ (t, sτ ) and Bef (t, sτ , se )}, the problem can sometimes be circumvented. Given a deterministic automaton defining Q (it can be a TA on fcns encoding, a stepwise tree automaton or an STA), one can construct an automaton of polynomial size recognizing the relation Bef&Can Q . Our objective is to define the formulas delay SQ and concur SQ in the logic FO ∃ (Eq, CanQ , S, Bef , Bef&Can Q ), preferably without using Bef . We start with defining relation Sel SQ = {(t, renτ (t), rene (t)) | (τ, e) ∈ sel SQ (t)} by an FO formula Sel SQ (Xt , Xτ , Xe ) with three free variables: Sel SQ (Xt , Xτ , Xe ) =df S(Xt ) ∧ Bef (Xt , Xτ , Xe ) ∧ ∀Xt ∈ TΣ . (S(Xt ) ∧ Eq(Xt , Xt , Xe )) ⇒ CanQ (Xt , Xτ ) Given automata defining Q and schema S, we can thus define an automaton recognizing Sel SQ (Xt , Xτ , Xe ). This yields an algorithm for deciding judgments (τ, e) ∈ sel SQ (t). It may be unefficient, though, since the automaton obtained this way may be huge, given that formula Sel SQ (Xt , Xτ , Xe ) uses full FO-logic of recognizable relations without restriction to some FO ∃ . Bounded Delay. We define the relation Delay SQ = {(t, ren τ (t), ren e (t)) | e ∈ delay SQ (t, τ )} by the following formula of FO ∃ (Eq, Bef&Can Q , S):

360

O. Gauwin, J. Niehren, and S. Tison

Delay SQ (Xt , Xτ , Xe ) =df ∃Xt ∈ TΣ . S(Xt ) ∧ Bef&Can Q (Xt , Xτ , Xe ) ∧ S(Xt ) ∧ Eq(Xt , Xt , Xe ) ∧ ¬CanQ (Xt , Xτ ) All base relations can be defined by deterministic automata of polynomial size when leaving n variable (since we don’t need relaton Bef here). Given deterministic automata A and B defining query Q and schema S = L(B), we can thus define a possibly nondeterministic automaton recognizing Delay SQ (Xt , Xτ , Xe ) in P-time from A and B. Let 2Delay SQ = {(t  sτ , se ) | Delay SQ (t, sτ , se )}. Both relations are recognized by the same automaton. This relation exactly captures the delay: val (2Delay SQ ) = |delay SQ |. Applying Corollary 1 to 2Delay SQ proves that bounded delay is decidable in P-time. Bounded Concurrency. For concurrency, we proceed in a similar manner. The relation Alive SQ = {(t, renτ (t), rene (t)) | τ ∈ alive SQ (t, e)} can be defined by the following formula of FO ∃ : Alive SQ (Xt ,Xe ,Xτ ) = ∃Xt ∈ TΣ .∃Xt ∈ TΣ .∃Xτ ∈ TBn .∃Xτ ∈ TBn . S(Xt )∧S(Xt ) ∧ CanQ (Xt , Xτ ) ∧ Eq Σ (Xt , Xt , Xe ) ∧ Eq Bn (Xτ , Xτ , Xe ) ∧ Bef • (Xτ , Xe ) ∧ ¬CanQ (Xt , Xτ ) ∧ Eq Σ (Xt , Xt , Xe ) ∧ Eq Bn (Xτ , Xτ , Xe ) ∧ C Bn (Xτ ) Here, Bef • is like Bef but for partial tuples, and C Bn ⊆ TBn is the set of trees of type 1n . Let 2Alive SQ be the binary version of Alive SQ , then val (2Alive SQ ) = |concur SQ |. Automata for C Bn and Eq Bn are necessarily of size O(2n ), which cannot be avoided by embedding them inside other relation like ¬CanQ . But for a fixed n, all these automata can be computed in P-time, so that Corollary 1 applied to 2Alive SQ proves that bounded concurrency can be decided in P-time. Conclusion. In this paper we proved that bounded delay and (for fixed n) bounded concurrency are both computable in P-time, for queries defined by dSTAs. This was obtained by studying some properties of recognizable relations on unranked trees, and combining them with prior results on the valuedness of tree transducers [17]. Considering the P-time translation of a fragment of XPath to dSTAs proposed in [10], we get the same complexity results for this fragment of XPath. Some questions are left open in the present paper. For fixed k and n, deciding k-boundedness for delay and concurrency for n-ary queries defined by dSTAs is known to be in NP-time. However, NP-hardness is still open. We also chose to define the delay for selection from the time point where the tuple gets complete. An alternative could be to define the ith delay, that starts when i components of the tuple are filled. Acknowledgments. This work was partially supported by the Enumeration project ANR-07-blanc.

References 1. Segoufin, L., Vianu, V.: Validating streaming XML documents. In: ACM PODS, pp. 53–64 (2002) 2. Martens, W., Neven, F., Schwentick, T., Bex, G.J.: Expressiveness and complexity of XML schema. ACM Transactions of Database Systems 31(3), 770–813 (2006)

Bounded Delay and Concurrency for Earliest Query Answering

361

3. Gupta, A.K., Suciu, D.: Stream processing of XPath queries with predicates. In: ACM SIGMOD, pp. 419–430 (2003) 4. Fernandez, M., Michiels, P., Sim´eon, J., Stark, M.: XQuery streaming ´ a la carte. In: 23nd International Conference on Data Engineering, pp. 256–265 (2007) 5. Benedikt, M., Jeffrey, A.: Efficient and expressive tree filters. In: Arvind, V., Prasad, S. (eds.) FSTTCS 2007. LNCS, vol. 4855, pp. 461–472. Springer, Heidelberg (2007) 6. Bar-Yossef, Z., Fontoura, M., Josifovski, V.: Buffering in query evaluation over XML streams. In: ACM PODS, pp. 216–227 (2005) 7. Olteanu, D.: SPEX: Streamed and progressive evaluation of XPath. IEEE Trans. on Know. Data Eng. 19(7), 934–949 (2007) 8. Gou, G., Chirkova, R.: Efficient algorithms for evaluating XPath over streams. In: ACM SIGMOD, pp. 269–280 (2007) 9. Berlea, A.: Online evaluation of regular tree queries. Nordic Journal of Computing 13(4), 1–26 (2006) 10. Gauwin, O., Niehren, J., Tison, S.: Earliest query answering for deterministic streaming tree automata and a fragment of XPath (2009) 11. Gauwin, O., Niehren, J., Roos, Y.: Streaming tree automata. Information Processing Letters 109(1), 13–17 (2008) 12. Alur, R.: Marrying words and trees. In: ACM PODS, pp. 233–242 (2007) 13. Alur, R., Madhusudan, P.: Visibly pushdown languages. In: 36th ACM Symposium on Theory of Computing, pp. 202–211 (2004) 14. Neumann, A., Seidl, H.: Locating matches of tree patterns in forests. In: Arvind, V., Ramanujam, R. (eds.) FST TCS 1998. LNCS, vol. 1530, pp. 134–146. Springer, Heidelberg (1998) 15. Comon, H., Dauchet, M., Gilleron, R., L¨ oding, C., Jacquemard, F., Lugiez, D., Tison, S., Tommasi, M.: (1997) (revised October 12th, 2007), http://tata.gforge.inria.fr 16. Carme, J., Niehren, J., Tommasi, M.: Querying unranked trees with stepwise tree automata. In: van Oostrom, V. (ed.) RTA 2004. LNCS, vol. 3091, pp. 105–118. Springer, Heidelberg (2004) 17. Seidl, H.: Single-valuedness of tree transducers is decidable in polynomial time. Theoretical Computer Science 106, 135–181 (1992) 18. Stearns, R.E., Hunt III, H.B.: On the equivalence and containment problems for unambiguous regular expressions, regular grammars and finite automata. SIAM Journal on Computing 14(3), 598–611 (1985) 19. Weber, A., Seidl, H.: On the degree of ambiguity of finite automata. In: Wiedermann, J., Gruska, J., Rovan, B. (eds.) MFCS 1986. LNCS, vol. 233, pp. 620–629. Springer, Heidelberg (1986) 20. Allauzen, C., Mohri, M., Rastogi, A.: General algorithms for testing the ambiguity of finite automata. In: Ito, M., Toyama, M. (eds.) DLT 2008. LNCS, vol. 5257, pp. 108–120. Springer, Heidelberg (2008) 21. Carme, J., Lemay, A., Niehren, J.: Learning node selecting tree transducer from completely annotated examples. In: Paliouras, G., Sakakibara, Y. (eds.) ICGI 2004. LNCS (LNAI), vol. 3264, pp. 91–102. Springer, Heidelberg (2004) 22. Seidl, H.: Ambiguity, valuedness and costs, Habilitation Thesis (1992) 23. Sakarovitch, J., de Souza, R.: Decidability of bounded valuedness for transducers. In: Mathematical Foundations of Computer Science (2008)

Learning by Erasing in Dynamic Epistemic Logic Nina Gierasimczuk Institute for Logic, Language, and Computation, University of Amsterdam Institute of Philosophy, University of Warsaw [email protected]

Abstract. This work provides a comparison of learning by erasing [1] and iterated epistemic update [2] as analyzed in dynamic epistemic logic (see e.g. [3]). We show that finite identification can be modelled in dynamic epistemic logic and that the elimination process of learning by erasing can be seen as iterated belief-revision modelled in dynamic doxastic logic.

1

Introduction

There have been many formal attempts to grasp the phenomenon of epistemic change. In this paper we will discuss two of them. On the one hand we have the formal learning theory (LT) framework (see e.g. [4]), with its direct implications for analysis of scientific discovery, on the other — belief-revision theory in its interrelation with dynamic epistemic logic (DEL). In learning theory, the classical framework of identification in the limit [5] was motivated mostly by the problem of language acquisition. It turned out to be very useful for modelling the process of grammar inference, and found numerous applications in the area of syntax. Initially the idea of identification was unappreciated in semantic considerations, but eventually also this direction has started to be developed resulting in applications to the acquisition of semantics of natural language [6,7,8] as well as in modelling the process of scientific inquiry [9]. The serious step towards involving more semantics was coupled with the design of model-theoretic learning [10] and its application to belief-revision theory [11]. Other, very prominent directions that explicitly involve notions of knowledge and belief have been developed in the area of epistemology. First, a precise language to discuss epistemic states of agents has been established in [12]. After that the need of formalizing dynamics of knowledge emerged. The belief-revision AGM framework [13] constitutes an attempt to talk about the dynamics of epistemic states. Belief-revision policies thus explained have been successfully modelled in dynamic epistemic logic (see [3]) and in the above-mentioned modeltheoretic learning [11]. In the present paper we show how those two important traditions, LT and DEL, can be merged. We explain this connection by joining iterated epistemic 

The author is a receiver of the Foundation for Polish Science Award for Young Researchers (START Programme 2008).

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 362–373, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Learning by Erasing in Dynamic Epistemic Logic

363

update as modelled in DEL with a special case of learning in the limit — learning by erasing [14,1]. We will proceed according to the following plan. First we explain the ideas of dynamic epistemic logic (DEL) from a strictly semantic point of view. We will also mention an important modification of DEL, namely dynamic doxastic logic (DDL). As we will see the part ‘dynamic’ in those names refers to the fact that those logics include operators which modify models. With respect to those modifications we discuss the notions of epistemic and doxastic update. In particular, we focus on public announcement as a special case. Then we leave this logical subject and move to briefly recall the basics of formal learning theory in its set-theoretical version. After that the definition of learning by erasing is provided. The last two parts present a way to model finite identification in DEL and learning by erasing in DDL.

2

Dynamic Epistemic Logic – Semantic Perspective

In general, dynamic epistemic logic has been introduced to formalize knowledge change. In this section basic notions of DEL will be provided. The definitions are based on [15]. Let us take Atom to be a set of atomic propositions and A — a set of agents. Definition 1 (Epistemic Model). Epistemic model M is a triple W, {∼i }i∈A , V , where W is a set of possible worlds, for each i ∈ A, ∼i ⊆ W × W is an indistinguishability relation and V : Atom → ℘(W ) is a valuation. Intuitively speaking, M formalizes the epistemic situation of all agents from A. The indistinguishability relation models their uncertainty about which of the possible worlds is the actual one. Definition 2 (Event Model). An event model E is a triple S, {→i }i∈A , pre, where S is a set of worlds, for each i ∈ A, →i ⊆ S × S, and pre : S → Atom is a pre-condition function which indicates what pre-condition a world has to satisfy to enable the event to take place. Event model describes the epistemic content of the event. Relation →i directly corresponds to the indistinguishability relation ∼i of epistemic model. Definition 3 (Product Update). Let M = W, {∼i }i∈A , V  and E = S, {→i }i∈A , pre. The product update M ⊗ E is the epistemic model M  = W  , {∼ i }i∈A , V   such that: – W  = {(w, s)|w ∈ W, s ∈ S and M, w |= pre(s)}, – (w, s) ∼i (w , s ) iff w ∼i w and s →i s , – V  ((w, s)) = V (w). Definition 4 (Public Announcement [16]). The public announcement of a formula ϕ is the event model Eϕ = S, {→i }i∈A , pre, such that S = {e} and for each i ∈ A, e →i e and pre(e) = ϕ.

364

N. Gierasimczuk

The major result of updating an epistemic model M with public announcement of ϕ is a submodel of M containing only the states that satisfy ϕ. Example 1. Let us take the set of agents A = {a (Anne), b (Bob), c (Carl)} and the deck of cards consisting of: 1, 2, 3. Each person gets one card. We can represent the situation after dealing as a triple xyz, where x, y, z are cards and the first position in the triple assigns the value to a (Anne), second to b (Bob), etc. For instance, 231 means that Anne has 2, Bob has 3 and Carl has 1. All possible situations after a deal are: 123, 132, 213, 231, 312, 321. We assume that all the players are witnessing the fact of dealing but they do not know the distribution of the cards. The epistemic model M of this situation is illustrated in the figure.

123 a 132 c

c

b a

213 b

b 231 c

312 a 321 Let us then assume that as a result the actual world is 231. Obviously each player’s knowledge does not allow certainty about which is the actual world. In the model the uncertainty of the agent x about the worlds w and w is symbolized by the following: w ∼x w (in the Figure this relation is depicted by two states being joined by a line labeled with x). Let us now assume that Anne shows her card to all the players publicly, i.e., all the players see her card and all of them know that all of them see it. This event is modelled by E = (S, {→i }i∈A , pre), where S = {s}, for each x ∈ A, s →x s and pre(s) = 2 (‘Anne has 2’).

a, b, c 2

The public announcement of ‘Anne has 2’ results in the epistemic situation, which can be presented as M  = M ⊗ E (depicted below).

213

a

231

Event E is an example of a public announcement, in this case: ‘Anne has 2’. In dynamic epistemic logic the public announcement of ϕ is represented by ‘!ϕ’ and corresponds to the elimination of all those possible worlds that do not satisfy ϕ. In other words, public announcement works as relativization of the model to those worlds that satisfy the content of the announcement.

Learning by Erasing in Dynamic Epistemic Logic

3

365

Dynamic Doxastic Logic

The objective of dynamic doxastic logic (DDL) is to formalize the notion of belief change. This is usually done by introducing preference relations over the possible worlds. Each agent has his own preference relation. Belief of agent a is determined by the set of his most preferred states. Definition 5 (Epistemic Plausibility Model). Let Atom be a set of atomic propositions and A — a set of agents. Epistemic plausibility model E is a quadruple: W, {∼i }i∈A , {≤i }i∈A , V  , where W is a set of possible worlds, for each i ∈ A, ∼i ⊆ W × W is an indistinguishability relation, ≤i ⊆ W × W is a preference relation and V : Atom → ℘(W ) is a valuation. Definition 6 (Plausibility Event Model). An event model E is a quadruple: S, {→i }i∈A , { i }i∈A , pre , where S is a set of worlds, for each i ∈ A, →i ⊆ S × S, i ⊆ S × S and pre : S → Atom is a pre-condition function. For completeness’ sake we add the definition of priority update. Definition 7 (Priority Update). The priority update works analogously to the epistemic update. The additional condition is for the ≤i relation: – for w ∈ W and s ∈ S, (w, s)≤ i (w , s ) iff s ≺i s , or s i s and w ≤i w , where s i s iff s i s and s i s.

4

Learning Theory

4.1

Identification in the Limit

Learning theory is concerned with the process of inductive inference [5]. We can think of it as of a game between Scientist and Nature. In the beginning we have a class of possible worlds together with a class of hypotheses (possible descriptions of worlds). Different hypotheses may describe the same world. We assume that both Scientist and Nature know what all the possibilities are, i.e., they both have access to the initial classes. Nature chooses one of those possible worlds to be the actual one. Scientist has to guess which it is. Scientist receives information about the world in an inductive manner. The stream of data is infinite and contains only and all the elements from the chosen reality. Each time Scientist receives a piece of information he answers with one of the hypotheses from the initial class. We say that Scientist identifies Nature’s choice in the limit if after some finite number of guesses his answers stabilize on a correct hypothesis. Moreover, to discuss more general identifiability, we require that the same is true for all the possible worlds from the initial class, i.e., regardless of which element from the class is chosen by Nature to be true, Scientist can identify it in the limit on the basis of data about the actual world. To formalize this simple setting we need to make the notion of stream of data clear. In learning theory such streams are often called ‘environments’1 . 1

We are concerned here only with sequences of positive information (texts).

366

N. Gierasimczuk

Let us consider E — the set of all computably enumerable sets. Let C ⊆ E be some class of c.e. sets. For each S in C we consider Turing machines hn which generate S and in such a case we say that n is an index of S. The Turing machines will function as the conjectures that Scientist makes. It is well-known that each S has infinitely many indices. Let us take IS to be the set of all indices of the set S, i.e, IS = {n|hn generates S}. Definition 8 (Environment). By environment of S, ε, we mean any infinite sequence of elements from S such that: 1. ε enumerates all the elements from S; 2. ε enumerates only the elements from S; 3. ε allows repetitions. Definition 9 (Notation). We will use the following notation: • • • • •

εn is the n-th element of ε; ε|n is a sequence (ε0 , ε1 , . . . , εn−1 ); SEQ denotes the set of all finite initial segments of all environments; set(ε) is a set of elements that occur in ε; hn will refer to a hypothesis, i.e., a finite description of a set, a Turing machine generating S; • L is a learning function — a map from finite data sequences to indices of hypotheses, L : SEQ → IHC . The structure of the identifiability in the limit can be formulated by the following chain of definitions: Definition 10 (Identification in the limit, LIM). We say that a learning function L: 1. identifies S ∈ C in the limit on ε iff there is a number k, such that for co-finitely many m, L(ε|m) = k and k ∈ IS ; 2. identifies S ∈ C in the limit iff it identifies S in the limit on every ε for S; 3. identifies C in the limit iff it identifies in the limit every S ∈ C. The notion of identifiability can be strengthened in various ways. One radical case is to introduce a finiteness condition for identification. Definition 11 (Finite identification, FIN). We say that a learning function L: 1. finitely identifies S ∈ C on ε iff, when successively fed ε, at some point L outputs a single k, such that k ∈ IS , and stops; 2. finitely identifies S ∈ C iff it finitely identifies S on every ε for S; 3. finitely identifies C iff it finitely identifies every S ∈ C.

Learning by Erasing in Dynamic Epistemic Logic

4.2

367

Learning by Erasing

Learning by erasing [1,17] is an epistemologically intuitive modification of identification in the limit. Very often the cognitive process of converging to a correct conclusion consists of eliminating those possibilities that are falsified during the inductive inquiry. Accordingly, in the formal model the outputs of the learning function are negative, i.e., the function each time eliminates a hypothesis, instead of explicitly guessing one that is supposed to be correct. A special case of learning by erasing is co-learning [14]. The set S ∈ C is co-learnable iff there is a function which stabilizes by eliminating all indices from IHC except just one from IS . The difference between this approach and the usual identification is in the interpretation of the positive guess of the learning function. In learning by erasing there is always some ordering of the initial hypothesis space. This allows to interpret the actual positive guess of the learning-by-erasing function to be the least hypothesis (in a given ordering) not yet eliminated. Let us give now the two definitions that explain the notion of learning by erasing. Definition 12 (Function Stabilization). In learning by erasing we say that a function stabilizes to number k on environment ε if and only if for co-finitely many n ∈ N: k = min{N − {L(ε|0), . . . , L(ε|n)}}. Definition 13 (Learning by Erasing, E-learning). We say that a learning function, L: 1. learns S ∈ C by erasing on ε iff L stabilizes to k on ε and k ∈ IS ; 2. learns S ∈ C by erasing iff it learns by erasing S from every ε for S; 3. learns C by erasing iff it learns by erasing every S ∈ C. A variety of additional conditions for learning can be defined. Let us mention the following conditions on e-learning function L [1]. 1. 2. 3. 4.

L erases all but one, correct hypothesis (co-learning, e-ALL); L erases only hypotheses that are incorrect (e-SUB); L erases exactly all hypotheses that are incorrect (e-EQ); L erases all hypotheses that are incorrect but may also erase some that are correct (e-SUPER);

Let us cite two theorems [1] that establish the relationships between various types of learning: e-learning, finite identifiability and identifiability in the limit. Theorem 1. FIN ⊂ e-EQ ⊂ e-SUB ⊂ LIM Theorem 2. e-ALL, e-SUPER = LIM

368

5

N. Gierasimczuk

Finite Identification in DEL

The word ‘learning’ is used in epistemology to cover a variety of epistemic processes. One of them is the epistemic update in the form of one-step learning that ϕ, followed by a direct modification of the set of beliefs, as we have seen in sections 2 and 3. In the learning-theoretic setting the incoming information is of a different nature than the actual thing being learned. This feature has an important consequence for modelling learning in DEL. We are forced to provide two-sorted models, with one sort for pieces of incoming information and another for the hypotheses. To establish a bridge between those two different ontologies we treat a hypothesis as the set of events that it predicts, e.g., if we take a hypothesis h to be ‘There are all natural numbers except 3’ it predicts that the environment will enumerate all the natural numbers except 3. The possible worlds in our epistemic model are identified with hypotheses. Unlike in the classical DEL approach, the event models are announcements of data corresponding to elements of the sets being learned, and not hypotheses themselves. A further difference is in the number of agents. In sections 2 and 3 we provided definitions for multi-agent epistemic cases. Although science as well as learning seem to be at least a two-player game, in the present paper we are concerned only with the role of Scientist (Learner). By implication, we assume Nature (Teacher) to be an objective machine that makes an arbitrary choice and gives out random data, she does not have any particular strategy, is neither helping the learner, nor obstructing his attempts to identify a correct hypothesis. We recognize the possibility and potential of analyzing two or more agents in the contexts of inductive inference. However, for the sake of simplicity our DEL and DDL models are going to account only for one agent. Let us again fix C to be a class of sets, and for each Sn ∈ C we consider hn to be a hypothesis that describes Sn . In learning by erasing we can take the initial epistemic model to represent the background knowledge of Scientist together with his uncertainty about which world is the actual one. Let us take the initial epistemic frame to be M = HC , ∼ , where HC is a possibly infinite2 set of worlds (hypotheses that are considered possible) and ∼⊆ HC × HC is an uncertainty relation for Scientist. Since we assume that the initial hypothesis space is arbitrary, we also do not require any particular preference of the scientist over HC . Hence, we take the relation ∼ to be a universal, equivalence binary relation over HC . The initial epistemic state of the Scientist is depicted in Figure 1. This model corresponds to the starting point of the scientific discovery process. Each world represents a hypothesis from the initial set determined by the background knowledge. In the beginning Scientist considers all of them possible. The model also reflects the fact that Scientist is given the class of hypotheses HC . In other words he knows what the alternatives are. 2

We can effectively deal with the epistemic update and identification in infinite domains by using special enumeration strategies (for explanation and examples see [18]).

Learning by Erasing in Dynamic Epistemic Logic

h0

∼

h1

∼

h2

∼

h3

∼

h4

∼

h5

369

∼ ...

Fig. 1. Initial epistemic model

Next, Nature decides on some state of the world by choosing one possibility from C. Let us assume that as a result h3 correctly describes the chosen world. Then, she decides on some particular environment ε, of the elements from the world. We picture this enumeration in Figure 2 below. ... ε3 ε2 ε1 ε0

Fig. 2. Environment ε consistent with h3

The sequence ε is successively given to Scientist. Let us focus now on the first step of the procedure. We have the uncertainty range of Scientist, it runs through the whole set of hypotheses HC . A piece of data ε0 is given to Scientist. This fact can be represented by the event model E0 = {e}, →, pre, where e → e and pre(e) = ε0 (see Figure 3).

ε0

Fig. 3. Event model E0 of the announcement of ε0

Scientist, when confronted with the announcement of ε0 updates his epistemic state accordingly. We will represent the process formally by the product update M ⊗ E0. The result of the product update is again an epistemic model M  = HC  , ∼ , where: 1. HC  = {(hn , e)|hn ∈ HC & pre(e) ∈ Sn )}; 2. ∼ =∼ |HC  . We use here event models similar in spirit to those of public announcement [16]. They consist in only one state with a pre-condition determined by the piece of data that is given. In Figure 4 Scientist’s confrontation with ε0 is depicted. Scientist tests each hypothesis with ε0 . If a hypothesis is consistent with it, it remains as a possibility, if it is not consistent, it is eliminated (see figure 5). Let us assume that ε0 is not consistent with h2 .

370

N. Gierasimczuk

h0

h1

h2

h3

h4

h5

...

ε0

Fig. 4. Confrontation with data

h0

h1

x

h3

h4

h5

...

h0

h1

h2

h3

h4

h5

...

ε0

Fig. 5. Epistemic update

This epistemic update can be iterated infinitely many times along ε resulting in an infinite sequence of models which according to the lines of DEL can be called ε-generated epistemic model (see e.g. [15]). Definition 14 (Generated Epistemic Model). The generated epistemic model (M )ε , with ε = ε0 , ε1 , ε2 , . . ., is the result of epistemic update M ⊗ E0 ⊗ E1 ⊗ E2 ⊗ . . ., where for each n, the event En corresponds to the announcement of εn . Let us now see a simple example of finite identification of a single hypothesis. Example 2. Let us take HC = {h0 , h1 , h2 }, such that hn = {0, ..., n}. Nature makes her choice regarding what the world is like. We assume that as a result h2 holds. Then, Nature chooses an enumeration ε = 0, 1, 0, 2, 1, . . .. After the first piece of data, 0, the uncertainty range of Scientist includes the whole HC . After the second, 1, Scientist eliminates h0 since it does not contain the event 1 and now he hesitates between h1 and h2 . The third piece, 0, does not change anything, however the next one, 2, eliminates h1 . Uncertainty is eliminated as well. He knows that the only hypothesis that can be true is h2 . Therefore, we can say that he learned it conclusively, with certainty. The above discussion suggests the following thesis. Thesis 1. Finite identifiability can be modelled within the DEL framework, using: – epistemic states for hypotheses; – infinite sequences of announcements for environments; – epistemic update for the progress in eliminating uncertainty over hypothesis space. Scientist succeeds in finite identification of S from ε if and only if there is a finite initial segment of ε, ε|n, such that the domain of the ε|n-generated model contains only one hypothesis hk and k ∈ IS . In other words, there is a finite step of the iterated epistemic update along ε, that eliminates Scientist’s uncertainty.

Learning by Erasing in Dynamic Epistemic Logic

6

371

Learning by Erasing in DDL

From Scientist’s point of view the process of learning has a few components that are very important in logical modelling. The first is of course the current conjecture — a hypothesis that is considered appropriate in a given step of the procedure. The second is the set of those hypotheses that were used in the past and have already been discarded. The third part is the set of hypotheses that are still considered to be possible, but for some reasons less probable than the chosen one. Let us consider the following example of a learning scenario, in which the uncertainty is never eliminated. Example 3. As you probably observed, in the Example 2 Scientist was very lucky. Let us assume for a moment that nature had chosen h1 , and had fixed the enumeration ε = 0, 1, 0, 1, 1, 1, 1, . . . In this case Scientist’s uncertainty can never be eliminated.3 This example indicates that the central element of the identification in the limit model is the unavoidable presence of uncertainty. The limiting framework allows however the introduction of some kind of operational knowledge, which is uncertainty-proof. To model the algorithmic nature of the learning process that includes actual guess and other not-yet-eliminated possibilities, we enrich the epistemic model with some preference relation ≤: HC × HC . The relation ≤ represents some preference over the set of hypotheses, e.g., if Scientist is an occamist, the preference would be defined according to the simplicity of hypotheses. In the initial epistemic state the uncertainty of the scientist again ranges over all of HC . This time however the class is ordered and Scientist current belief is the most preferred hypothesis. Therefore, we consider the initial epistemic state of Scientist to be: M = HC , ∼, ≤ . The procedure of erasing hypotheses that are inconsistent with successively incoming data is the same as in the previous section. This time however let us introduce the current-guess state which is interpreted as the actual guess of the Scientist. It is always the one that is most preferred — the smallest one according to ≤. In doxastic logic a set of most preferred hypotheses is almost invariably interpreted as the one that the agent believes in. Let us go back to Example 2, where Nature chose a world consistent with h1 . After seeing 1 and eliminating h0 , Scientist’s attention focuses on h1 , then h1 is his current belief. It is the most preferred hypothesis, and as such it can be reiterated as long as it is consistent with ε. In this particular case, since Nature chose a world consistent with h1 , 3

As we are interested here in learning by erasing, we assume a suitable underlying ordering of hypothesis space. In this case it is: h0 , h1 , h2 . However, note that this type of identification is not order-independent. If the initial ordering was: h0 , h2 , h1 , then Scientist would not stabilize on the correct hypothesis.

372

N. Gierasimczuk

it will never be contradicted, so Scientist will always be uncertain between h1 and h2 . However, his preference directs him to believe in the correct hypothesis, without him being aware of the correctness. Therefore, we claim the following. Thesis 2. Learning by erasing can be modelled within the DDL framework, using: – epistemic states for hypotheses; – infinite sequences of announcements for environments; – epistemic update for the progress in eliminating uncertainty over the hypothesis space; – preference relation for the underlying hypothesis space; – in each step of the procedure, the most preferred hypothesis for the actual positive guess of the learning function. Scientist learns S by erasing from ε if and only if there is n such that for every m > n, the most preferred state of the domain of the ε|m-generated epistemic model is hk , and k ∈ IS .

7

Conclusions and Further Work

In this paper we argued that the process of inductive inference can be modelled in dynamic epistemic logic and dynamic doxastic logic. To support our claim we provided a translation of the components of learning into a two-sorted semantics for DEL and DDL. In particular, we see DEL as an appropriate framework to analyze the notion of finite identifiability. Learning by erasing, a special case of identifiability in the limit, is based on the existence of an underlying ordering of hypothesis space. Therefore, in logical modelling it requires adding to the epistemic model a preference relation over possible worlds. This indicates that it should be formalized in DDL, where the preference relation is a standard element of any model. The above-presented conceptual work has many implications and possible continuations. After establishing a correspondence on the semantic level, it is possible to formulate axioms of epistemic logic for inductive inference. We find this project promising and potentially fruitful for both DEL and LT. Moreover, modal analysis of the process of learning can be continued in the following directions: – formulating LT theorems as validities in epistemic and temporal logic; – analyzing the inductive inference process in game-theoretical terms, and discussing strategies for learning and teaching; – studying the notion of non-introspective operational knowledge and uncertainty that are involved in the process of inductive inference; – comparing formal learning theory and belief-revision theory in a systematic way.

Learning by Erasing in Dynamic Epistemic Logic

373

References 1. Lange, S., Wiehagen, R., Zeugmann, T.: Learning by erasing. In: Arikawa, S., Sharma, A.K. (eds.) ALT 1996. LNCS (LNAI), vol. 1160, pp. 228–241. Springer, Heidelberg (1996) 2. Baltag, A., Moss, L.: Logics for epistemic programs. Synthese 139(2), 165–224 (2004) 3. van Ditmarsch, H., van der Hoek, W., Kooi, B.: Dynamic Epistemic Logic. Springer, Heidelberg (2007) 4. Jain, S., Osherson, D., Royer, J.S., Sharma, A.: Systems that Learn. MIT Press, Cambridge (1999) 5. Gold, E.: Language identification in the limit. Information and Control 10, 447–474 (1967) 6. Tiede, H.J.: Identifiability in the limit of context-free generalized quantifiers. Journal of Language and Computation 1, 93–102 (1999) 7. Costa Florˆentio, C.: Learning generalized quantifiers. In: Proc. 7th ESSLLI Student Session (2002) 8. Gierasimczuk, N.: The problem of learning the semantics of quantifiers. In: ten Cate, B.D., Zeevat, H.W. (eds.) TbiLLC 2005. LNCS (LNAI), vol. 4363, pp. 117– 126. Springer, Heidelberg (2007) 9. Kelly, K.: The Logic of Reliable Inquiry. Oxford University Press, Oxford (1996) 10. Osherson, D., de Jongh, D., Martin, E., Weinstein, S.: Formal learning theory. In: van Benthem, J., Ter Meulen, A. (eds.) Handbook of Logic and Language, pp. 737–775. MIT Press, Cambridge (1997) 11. Martin, E., Osherson, D.: Elements of Scientific Inquiry. MIT Press, Cambridge (1998) 12. Hintikka, J.: Knowledge and Belief. An Introduction to the Logic of the Two Notions. Cornell University Press (1962) 13. Alchourr´ on, C.E., G¨ ardenfors, P., Makinson, D.: On the logic of theory change: Partial meet contraction and revision functions. The Journal of Symbolic Logic 50(2), 510–530 (1985) 14. Freivalds, R., Zeugmann, T.: Co–learning of recursive languages from positive data. In: Bjorner, D., Broy, M., Pottosin, I.V. (eds.) PSI 1996. LNCS, vol. 1181, pp. 122– 133. Springer, Heidelberg (1996) 15. van Benthem, J., Gerbrandy, J., Pacuit, E.: Merging frameworks for interaction: DEL and ETL. In: Proc. TARK 2007, pp. 72–81 (2007) 16. Batlag, A., Moss, L.S., Solecki, S.: The logic of public announcements and common knowledge and private suspicions. In: Proc. TARK 1998, pp. 43–56 (1998) 17. Freivalds, R., Karpinski, M., Smith, C., Wiehagen, R.: Learning by the process of elimination. Information and Computation 176(1), 37–50 (2002) 18. Gierasimczuk, N.: Identification through inductive verification. Application to monotone quantifiers. In: Bosch, P., Gabelaia, D., Lang, J. (eds.) TbiLLC 2007. LNCS, vol. 5422, pp. 193–205. Springer, Heidelberg (2009)

The Fault Tolerance of NP-Hard Problems Christian Glaßer1 , A. Pavan2, , and Stephen Travers1 1

Julius-Maximilians-Universit¨ at W¨ urzburg, Germany {glasser,travers}@informatik.uni-wuerzburg.de 2 Iowa State University, USA [email protected]

Abstract. We study the effects of faulty data on NP-hard sets. We consider hard sets for several polynomial time reductions, add corrupt data and then analyze whether the resulting sets are still hard for NP. We explain that our results are related to a weakened deterministic variant of the notion of program self-correction by Blum, Luby, and Rubinfeld. Among other results, we use the Left-Set technique to prove that mcomplete sets for NP are nonadaptively weakly deterministically selfcorrectable while btt-complete sets for NP are weakly deterministically self-correctable. Our results can also be applied to the study of Yesha’s p-closeness. In particular, we strengthen a result by Ogiwara and Fu.

1

Introduction

Even small amounts of faulty data can obscure reasonable information. For instance, by filling more and more whitespaces of a printed text with arbitrary letters, it can become quite difficult to understand the original meaning of the text. The same holds true for NP-complete sets. Take for instance SAT, the set of all satisfiable formulas. By adding false positives to SAT, i.e., some unsatisfiable formulas, we can actually lose information: If we overdo it, we end up with SAT ∪ SAT = Σ ∗ , and by this definitely lose NP-completeness. But how much false positive data can NP-hard sets handle, i.e., how many false positives can we add such that the resulting set stays NP-hard? Alternatively, how much effort is needed to extract the original information? In this paper, we investigate how polynomial time reductions can cope with false positives. More precisely, we consider NP-hard sets for several polynomial time reductions and add false positives to the sets. Moreover, we study the effects of more general kinds of faulty data. We investigate how polynomial time reductions can handle combinations of both, false positives and false negatives. This relates our research to the notion of program self-correction which was introduced by Blum, Luby, and Rubinfeld [1]. That notion addresses a fundamental question regarding software reliability: Can one increase the reliability of existing software without understanding the way it 

Research supported in part by NSF grant CCF-0430807.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 374–385, 2009. c Springer-Verlag Berlin Heidelberg 2009 

The Fault Tolerance of NP-Hard Problems

375

works? More precisely, let P be a program that is designed to solve a problem L. However, we do not know whether P is correct. Is it possible to write an auxiliary program M that uses P such that if P errs only on a small fraction of the inputs, then with high probability M corrects the errors made by P ? So M has to find the right answer with high probability by calling P on several inputs. Our investigations of the consequences of faulty data are related to a considerably weakened deterministic variant of self-correction. In this case, the error probability of the polynomial-time wrapping machine M must be 0, i.e., M must achieve certainty about the question of whether the input belongs to L. However, we only require M to correct very few errors (i.e., p(n) errors for some polynomial p). For probabilistic self-correction however, a probabilistic polynomial-time corrector must be able to correct up to 2n /p(n) errors for some polynomial p. We prove that – The symmetric difference of m-hard sets and sparse sets is always tt-hard. This implies that m-complete sets for NP are nonadaptively weakly deterministically self-correctable. – The symmetric difference of btt-hard sets and arbitrary sparse sets is always T-hard. This implies that btt-complete sets are weakly deterministically selfcorrectable. – The union of dtt-hard sets and arbitrary sparse sets is always T-hard. These results show that ≤pm -hard, ≤pbtt -hard, and ≤pdtt -hard sets do not become too easy when false positives are added (as they stay NP-hard with respect to more general reducibilities). On the other hand, we show that unless P = NP, there exist sparse sets S1 , S2 such that SAT ∪ S1 is not ≤pbtt -hard for NP, and SAT ∪ S2 is not ≤pdtt -hard for NP. Furthermore, we explain that one of our results about btt-reducibility is related to the notion of p-closeness which was introduced by Yesha [2]. We show that no ≤pbtt -hard set for NP is p-close to P, unless P = NP. This strengthens a result by Ogiwara [3] and Fu [4] who proved that no ≤pm -hard set for NP is p-close to P, unless P = NP.

2

Preliminaries

We recall basic notions. Σ denotes a finite alphabet with at least two letters, Σ ∗ denotes the set of all words, and |w| denotes the length of a word w. For n ≥ 0, Σ n denotes the set of all words of length n. A set A ⊆ Σ ∗ is nontrivial if A = ∅ and A = Σ ∗ . A tally set is a subset of 0∗ . The census function of a set S df is defined as censusS (n) = |S ∩ Σ n |. A set S is sparse if there exists a polynomial p such that for all n ≥ 0, censusS (n) ≤ p(n). The symmetric difference of sets A and B is defined as A B = (A − B) ∪ (B − A). The language accepted by a machine M is denoted by L(M ). The characteristic function of a set A is denoted by cA . L denotes the complement of a language L and coC denotes the class of complements of languages in C. FP denotes the class of functions computable in deterministic polynomial time.

376

C. Glaßer, A. Pavan, and S. Travers

We recall standard polynomial-time reducibilities [5]. A set B many-onereduces to a set C (m-reduces for short; in notation B≤pm C) if there exists a total, polynomial-time-computable function f such that for all strings x, x ∈ B ⇔ f (x) ∈ C. A set B Turing-reduces to a set C (T-reduces for short; in notation B≤pT C) if there exists a deterministic polynomial-time-bounded oracle Turing machine M such that for all strings x, x ∈ B ⇔ M with C as oracle accepts the input x. A set B truth-table-reduces to a set C (tt-reduces for short; in notation B≤ptt C) if there exists a deterministic polynomial-time-bounded oracle Turing machine M that queries nonadaptively such that for all strings x, x ∈ B ⇔ M with C as oracle accepts the input x. A set B disjunctively truth-table-reduces to a set C (dtt-reduces for short; in notation B≤pdtt C) if there exists a total, polynomial-time-computable function f : Σ ∗ → P(Σ ∗ ) such that for all strings x, x ∈ B ⇔ f (x) ∩ C = ∅. A set B conjunctively truth-table-reduces to a set C (ctt-reduces for short; in notation B≤pctt C) if there exists a total, polynomial-time-computable function f : Σ ∗ → P(Σ ∗ ) such that for all strings x, x ∈ B ⇔ f (x) ⊆ C. A set B bounded truth-table-reduces to a set C (btt-reduces for short; in notation B≤pbtt C) if there exists a k ≥ 1, a k-ary Boolean function α, and g1 , . . . , gk ∈ FP such that for all x x ∈ B ⇔ α(cC (g1 (x)), cC (g2 (x)), . . . , cC (gk (x))) = 1. A set B is many-one-hard (m-hard for short) for a complexity class C if every B ∈ C m-reduces to B. If additionally B ∈ C, then we say that B is manyone-complete (m-complete for short) for C. Similarly, we define hardness and completeness for other reducibilities. We use the term C-complete as an abbreviation for m-complete for C. A set L is paddable [6] if there exists f (·, ·), a polynomial-time computable, injective polynomial-time invertible function such that for all x and y, x ∈ L ⇐⇒ f (x, y) ∈ L. 2.1

Weak Deterministic Self-correction

We introduce the notion of weak deterministic self-correction which is a deterministic variant of (probabilistic) self-correction [1]. The prefix weak indicates that our notion of deterministic self-correction does not necessarily imply probabilistic self-correction in the sense of Blum, Luby, and Rubinfeld [1]. The difference is as follows: For weak deterministic self-correction, we require that a sparse amount of errors can be corrected by a deterministic polynomial-time corrector. For probabilistic self-correction however, a probabilistic polynomial-time corrector must be able to correct up to 2n /p(n) errors for some polynomial p. Definition 1. L is weakly deterministically self-correctable if for every polynomial q there exists a polynomial-time machine M such that L≤pT P via M whenever the census of L P is bounded by q. If M queries nonadaptively, then L is nonadaptively weakly deterministically self-correctable. The set P in the definition formalizes a program for L that errs on at most q(n) inputs of length n. So L is weakly deterministically self-correctable if there

The Fault Tolerance of NP-Hard Problems

377

exists an auxiliary machine M that corrects all programs that err on at most q(n) inputs of length n. The next theorem shows that such a universal M surprisingly exists already if the single programs can be corrected with possibly different machines. This establishes the connection between weak deterministic self-correction and the robustness against false positives. Theorem 1. L is weakly deterministically self-correctable ⇔ L≤pT L S for all sparse S. Proof ⇒: This is a direct consequence of Definition 1. ⇐: Assume that L is not weakly deterministically self-correctable. So there exists a polynomial q such that ∀polynomial-time machine M , ∃T ⊆ Σ ∗ [censusT ≤ q and L = L(M LT )]. (1) We construct a sparse S such that L  ≤pT L S. The construction is stagewise where  in step i we construct a finite set Si such that S1 ⊆ S2 ⊆ · · · and df S = i≥1 Si . Let M1 , M2 , . . . be an enumeration of all deterministic, polynomial-time Turing machines such that Mi runs in time ni + i. Let S0 = ∅. For i ≥ 1, the set Si is constructed as follows: Choose n large enough such that Si−1 ⊆ Σ k, Si ∩ Σ j = Sk ∩ Σ j ). In the definition of Sk it holds that |Q| ≤ k ≤ n. So in step 5, at most n words are added to S and these words are of length greater than n. Therefore, for all i ≥ 0, |S ∩ Σ i | ≤ i and hence S is sparse. Assume SAT ∪ S is ≤pbtt -hard for NP. So there exists a k ≥ 1 such that SAT≤pbtt SAT ∪ S via Mk . Consider the construction of Sk and let n, T , x, and Q be the corresponding variables. In all steps i ≥ k, S will be only changed with respect to words of lengths greater than n. Therefore, S ∩ Σ ≤n = Sk−1 and hence (3) ∀w ∈ Σ ≤n , (w ∈ SAT ∪ S ⇔ w ∈ T ). If q is an oracle query of MkT (x) that is longer than n, then q ∈ Q and hence q ∈ Sk ⊆ S. So q ∈ SAT ∪ S and q ∈ T . Together with (3) this shows that the computations MkT (x) and MkSAT∪S (x) are equivalent. From step 3 it follows that MkSAT∪S (x) accepts if and only if x ∈ / SAT. This contradicts the assumption that Mk reduces SAT to SAT ∪ S. Hence SAT ∪ S is not ≤pbtt -hard for NP. 2 ⇒ 1: If P = NP, then for all sparse S, SAT ∪ S is trivially ≤pm -complete for NP. 1 ⇔ 3: Analogous to the equivalence of 1 and 2; we only sketch the differences. We use an enumeration of ≤pdtt -reduction machines (i.e., machines that nonadaptively query an arbitrary number of strings and that accept if at least one query is answered positively). Moreover, we change the definition of Sk in step 5 such that ⎧ ⎨ Sk−1 : if Q = ∅ df Sk = ⎩S ∪ {q} : if Q = ∅, where q = max(Q). k−1

This makes sure that S is sparse. Assume SAT≤pdtt SAT ∪ S via Mk . If no query of MkT (x) is longer than n, then T Mk (x) and MkSAT∪S (x) are equivalent computations and hence L(MkSAT∪S ) = SAT by step 3. Otherwise, there exists a query that is longer than n. Let q be the greatest such query and note that q ∈ Sk ⊆ S. This query gets a positive answer in the computation MkT (x). So the computation accepts and by step 3, x ∈ / SAT.

384

C. Glaßer, A. Pavan, and S. Travers

In the computation MkSAT∪S (x), the query q also obtains a positive answer and hence the computation accepts. So also in this case, L(MkSAT∪S ) = SAT. This shows that SAT ∪ S is not ≤pdtt -hard for NP.   Theorem 6 tells us that while ≤pm -hard, ≤pbtt -hard, and ≤pdtt -hard sets do not become too easy when false positives are added (as they stay NP-hard with respect to more general reducibilities, confer sections 3.1, 3.2, and section 3.3), they are not robust against sparse sets of false positives. The next result says that this is different for hard sets which are paddable. Proposition 1. Let L be paddable and let S be sparse. 1. If L is ≤ptt -hard for NP, then L ∪ S is ≤ptt -hard for NP. 2. If L is ≤pT -hard for NP, then L ∪ S is ≤pT -hard for NP. 3. If L is ≤pctt -hard for NP, then L ∪ S is ≤pctt -hard for NP. In Theorem 6 we have seen that ≤pm -complete, ≤pbtt -complete, and ≤pdtt -complete sets are not robust against sparse sets of false positives. The following corollary of Proposition 1 explains the difficulty of showing the same for ≤pctt -complete, ≤ptt -complete, and ≤pT -complete sets. Corollary 7 1. If there exists a ≤ptt -complete set L in NP and a sparse S such that L ∪ S is not ≤ptt -hard for NP, then there exist ≤ptt -complete sets in NP that are not paddable. 2. If there exists a ≤pT -complete set L in NP and a sparse S such that L ∪ S is not ≤pT -hard for NP, then there exist ≤pT -complete sets in NP that are not paddable. 3. If there exists a ≤pctt -complete set L in NP and a sparse S such that L ∪ S is not ≤pctt -hard for NP, then there exist ≤pctt -complete sets in NP that are not paddable.

References 1. Blum, M., Luby, M., Rubinfeld, R.: Self-testing/correcting with applications to numerical problems. Journal of Computer and System Sciences 47(3), 549–595 (1993) 2. Yesha, Y.: On certain polynomial-time truth-table reducibilities of complete sets to sparse sets. SIAM Journal on Computing 12(3), 411–425 (1983) 3. Ogiwara, M.: On P-closeness of polynomial-time hard sets (manuscript, 1991) 4. Fu, B.: On lower bounds of the closeness between complexity classes. Mathematical Systems Theory 26(2), 187–202 (1993) 5. Ladner, R.E., Lynch, N.A., Selman, A.L.: A comparison of polynomial time reducibilities. Theoretical Computer Science 1, 103–123 (1975) 6. Berman, L., Hartmanis, J.: On isomorphism and density of NP and other complete sets. SIAM Journal on Computing 6, 305–322 (1977)

The Fault Tolerance of NP-Hard Problems

385

7. Glaßer, C., Pavan, A., Selman, A.L., Zhang, L.: Redundancy in complete sets. In: Durand, B., Thomas, W. (eds.) STACS 2006. LNCS, vol. 3884, pp. 444–454. Springer, Heidelberg (2006) 8. Fortune, S.: A note on sparse complete sets. SIAM Journal on Computing 8(3), 431–433 (1979) 9. Ogiwara, M., Watanabe, O.: On polynomial-time bounded truth-table reducibility of NP sets to sparse sets. SIAM Journal on Computing 20(3), 471–483 (1991) 10. Ogiwara, M., Lozano, A.: On sparse hard sets for counting classes. Theoretical Computer Science 112(2), 255–275 (1993) 11. Sch¨ oning, U.: Complete sets and closeness to complexity classes. Mathematical Systems Theory 19(1), 29–41 (1986) 12. Hemachandra, L.A., Ogiwara, M., Watanabe, O.: How hard are sparse sets? In: Structure in Complexity Theory Conference, pp. 222–238 (1992)

Termination of Priority Rewriting Isabelle Gnaedig INRIA & LORIA BP 101, 54602 Villers-l`es-Nancy Cedex France

Abstract. Introducing priorities in rewriting increases the expressive power of rules and helps to limit computations. Priority rewriting is used in rule-based programming as well as in functional programming. Termination of priority rewriting is then important to guarantee that programs give a result. We describe an inductive proof method for termination of priority rewriting, relying on an explicit induction on the termination property and working by generating proof trees, which model the rewriting relation by using abstraction and narrowing.

1

Introduction

In [1,2], priority rewriting systems (PRSs in short) have been introduced. A PRS is a term rewrite system (TRS in short) with a partial ordering on rules, determining a priority between some of them. Considering priorities on the rewrite rules to be used can be very useful for an implementation purpose, to reduce the non-determinism of computations or to enable divergent systems to terminate, and for a semantical purpose, to increase the expressive power of rules. Priority rewriting is enabled in rule-based languages like ASF+SDF [3] or Maude [4]. It is also used as a computation model for functional programming [5], and is underlying in the functional strategy, used for example in Lazy ML [6], Clean [7], or Haskell [8]. Let us also cite recent works on specification and correctness of security policies using rewriting with priorities [9,10]. But priority rewriting is delicate to handle. First, the priority rewriting relation is not always decidable, because a term rewrites with a given rule only if in the redex, there is no reduction leading to another redex, reducible with a rule of higher priority. A way to overcome the undecidability can be to force evaluation of the terms in reducing subterms to strong head normal form via some strategy [5], or to use the innermost strategy [11]. But in these cases, normalization can lead to non-termination. Second, the semantics of a PRS is not always clearly defined. In [1], a semantics is proposed, relying on a notion of unique sound and complete set of closed instances of the rules of the PRS, and it is shown that bounded -the bounded property is weaker than termination- PRSs have a semantics. In [12], a fixed point based technique is proposed to compute the semantics of a PRS. It is also proved that for a bounded PRS with finitely many rules, the set of successors of any term is finite and computable. In [11], a logical semantics of PRSs based on equational logic is given. A particular class of PRSs is proved sound and A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 386–397, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Termination of Priority Rewriting

387

complete with respect to the initial algebra, provided every priority rewriting sequence from every ground term terminates. Then the termination problem of the priority rewriting relation naturally arises, either to guarantee that it has a semantics, or to ensure that rewriting computations always give a result. Surprisingly, it seems not to have been much investigated until now. Let us cite [13], discussing a normalizing strategy of PRSs i.e., a strategy giving only finite derivations for terms having a normal form with usual rewriting, and [14], where it is proved that termination of innermost rewriting implies termination of generalized innermost rewriting with ordered rules. But to our knowledge, the problem of finding a specific termination proof technique has only been addressed in [11], where the use of reduction orderings is extended with an instantiation condition on rules linked with the priority order. Our purpose here is to consider the termination proof of priority rewriting from an operational point of view, with the concern of guaranteeing a result for every computation. So it seems interesting to focus on the innermost priority rewriting of [11], because it is decidable, easy to manipulate, and the innermost strategy is often used in programming contexts where priorities on rules are considered. The previously cited works on rule-based security policies also generated a need of specific termination tools: the specifications given in [9] have indeed been executed in TOM [15] with an innermost evaluation mechanism. We use an inductive approach, whose principle has already been applied for termination of rewriting under strategies [16]. The idea is to prove, in developing proof trees simulating the rewriting trees, that every derivation starting from any term terminates, supposing that it is true for terms smaller than the starting terms. We then introduce the priority notion in the generation mechanism of the proof trees, and show how to optimize the technique in this new case.

2

Priority Rewriting

We assume that the reader is familiar with the basic definitions and notations of term rewriting given for instance in [17,18]. The ones needed in the paper can also be found in [19]. We just recall that T (F , X ) is the set of terms built from a given finite set F of function symbols f , and a set X of variables denoted by x, y . . .. T (F ) is the set of ground terms (without variables). Positions in a term are represented as sequences of integers. The empty sequence  denotes the top position. For a position p of a term t, we denote by t|p the subterm of t at position p, and by t[s]p the term obtained by replacing in t the subterm t|p by s. A substitution is an assignment from X to T (F , X ), written σ = (x1 = t1 , . . . , xn = tn ) whose domain, denoted by Dom(σ), is {x1 , . . . , xn }. It uniquely extends to an endomorphism of T (F , X ). Its application to a term t ∈ T (F , X ) is written σt. An instantiation or ground substitution is an assignment from X to T (F ). Id denotes the identity substitution. Given a term rewrite system R, a function symbol in F is called a constructor iff it does not occur in R at the top position of a left-hand side (lhs in short) of rule, and is called a defined function symbol otherwise. The set of defined function symbols is denoted by D.

388

I. Gnaedig

A priority term rewrite system is a pair (R, ) of a term rewrite system R (always considered as finite here) and a partial ordering  on the rules of R. A rule r1 has a higher priority than a rule r2 iff r1  r2 , which is also written ↓rr12 . Definition 1 ([11]). Let R be a PRS on T (F , X ). A term s is IP -reducible and (IP -) rewrites to t at position p with the rule l → r, and the substitution σ which is written s →IP p,l→r,σ t iff: • s rewrites into t : t = s[σr]p with s|p = σl, • no proper subterm of the redex s|p is IP −reducible, • s|p is not IP −reducible by any rule in R of higher priority than l → r. Example 1. With the PRS {f (g(x)) → b, g(a) → c  g(a) → d}, on f (g(a)), the first rule should apply, but this would not be an innermost rewrite step. So the second rule applies, but the third one does not, because g(a) → c  g(a) → d. A PRS R IP -terminates if and only if every IP -rewriting chain (IP -derivation) of the rewriting relation induced by R is finite. If t is in an IP -derivation issued from t and t is IP -irreducible, then t is called a(n) (IP -)normal form of t and is denoted by t↓. Note that given t, t↓ may be not unique.

3

Inductively Proving Termination of IP-Rewriting

We prove termination of IP -rewriting by induction on the ground terms. Working on ground terms is appropriate, since most of the time, the algebraic semantics of rule-based languages is initial. Moreover, in [11], to guarantee stability by substitution of the innermost rewriting relation, the rules without highest priority only can reduce ground terms. Finally, there are TRSs which are noninnermost terminating on T (F , X ) and innermost terminating on T (F ). A termination proof method working on T (F , X ) could not handle them. For proving that a PRS on T (F ) IP -terminates, we reason with a local notion of termination on terms: a term t of T (F ) is said to be IP -terminating for a PRS R if every IP -rewriting chain starting from t is finite. For proving that a term t of T (F ) is IP -terminating, we then proceed by induction on T (F ) with a noetherian ordering , assuming the property for every t such that t  t . To guarantee non emptiness of T (F ), we assume that F contains at least one constructor constant. Rewriting derivations are simulated, using a lifting mechanism, by proof trees developed from initial patterns tref = g(x1 , . . . , xm ) on T (F , X ), for every g ∈ D, by alternatively using narrowing and an abstraction mechanism. For a term t of T (F , X ) occurring in a proof tree, – first, some subterms θt|j of θt are supposed to be IP -terminating for every instantiation θ by the induction hypothesis, if θtref  θt|j for the induction ordering . So the t|j are replaced in t by abstraction variables Xj representing respectively any of their normal forms. Reasoning by induction allows us to only suppose the existence of the normal forms without explicitly computing them. Obviously, the whole term t can be abstracted. If the ground

Termination of Priority Rewriting

389

instances of the resulting term are IP -terminating (either if the induction hypothesis can be applied to them, or if they can be proved IP -terminating by other means presented later), then the ground instances of the initial term are IP -terminating. Otherwise, – the resulting term u = t[Xj ]{i1 ,...,ip } (i1 , . . . , ip are the abstraction positions in t) is narrowed in all possible ways into terms v, with an appropriate narrowing relation corresponding to IP -rewriting u according to the possible instances of the Xj . The process is iterated on each v, until we get a term t such that either θtref  θt , or θt can be proved IP -terminating. This technique was inspired from the one we proposed for proving the innermost termination of classical rewrite systems in [16]. We now give the concepts needed to formalize and automate it.

4

Abstraction, Narrowing, Constraints

Ordering Constraints. The induction ordering is not defined a priori but is constrained along the proof by inequalities between terms that must be comparable, called ordering constraints, each time the induction hypothesis is used for abstraction. More formally, an ordering constraint is a pair of terms of T (F , X ) denoted by (t > t ). It is said to be satisfiable if there is an ordering , such that for every instantiation θ whose domain contains Var (t) ∪ Var (t ), we have θt  θt . We say that  satisfies (t > t ). A conjunction C of ordering constraints is satisfiable if there is an ordering satisfying all conjuncts. The empty conjunction, always satisfied, is denoted by . Satisfiability of a constraint conjunction of this form is undecidable. But a sufficient condition for C to be satisfiable is to find a simplification ordering  such that t  t for every constraint t > t of C. The constraints generated by our approach are often satisfiable by a Recursive Path Ordering or a Lexicographic Path Ordering. Otherwise, automatic constraint solvers can provide adequate polynomial orderings. See [16] for experiments. Abstraction. Let N be a set of variables disjoint from X . Symbols of N are called abstraction variables. Substitutions and instantiations are extended to T (F , X ∪ N ) so that for every substitution σ (resp. instantiation θ) such that Dom(σ) (resp. Dom(θ)) contains a variable X ∈ N , σX (resp. θX) is in IP normal form. The formal definition of a term abstraction can be found in [16]. IP -termination on T (F ) is in fact proved by reasoning on terms with abstraction variables i.e., on terms of T (F , X ∪ N ). Ordering constraints are extended on T (F , X ∪ N ). When a subterm t|j is abstracted by Xj , we state an abstraction constraint t|j ↓ = Xj where t ∈ T (F , X ∪ N ) and X ∈ N , to express that its instances can only be normal forms of the corresponding instances of t|j . Narrowing. After abstracting the current term t into t = t[Xj ]j∈{i1 ,...,ip } , we test whether the possible ground instances of t are reducible, according to the possible values of the instances of the Xj , by narrowing t with the PRS.

390

I. Gnaedig

To schematize innermost rewriting on ground terms, in [16], we introduced a specific narrowing definition involving constrained substitutions. The problem here is to see how to express priorities in the narrowing mechanism and how to integrate them in the previous constraint based definition. In [16], the usual notion of narrowing was refined as follows. With the usual innermost narrowing relation, if a position p in a term t is a narrowing position, no suffix position of p can be a narrowing position as well. However, if we consider ground instances of t, we can have rewriting positions p for some instances, and p for other instances, such that p is a suffix position of p. So, when using the narrowing relation to schematize innermost rewriting of ground instances of t, the narrowing positions p to consider depend on a set of ground instances of t, which is defined by excluding the ground instances of t that would be narrowable at some suffix position of p. For instance, with the TRS R = {g(a) → a, f (g(x)) → b}, the innermost narrowing positions of the term f (g(X)) are 1 with the narrowing substitution σ = (X = a), and  with any σ such that σX = a. This leads us to introduce constrained substitutions. Let σ be a substitution on T (F , X ∪ N ). In the  following, we identify σ = (x1 = t1 , . . . , xn = tn ) with the equality formula i (xi = ti ), with xi ∈ X ∪ N , ti ∈ T (F , X ∪ N ). Similarly, we call negation σ of the substitution σ the formula  i (xi = ti ). The negation of Id means that no substitution can be applied.   Definition 2 ([16]). A substitution σ is said to satisfy a constraint j ij (xij   = tij ), iff for every ground instantiation θ, j ij (θσxij = θσtij ). A constrained   substitution σ is a formula σ0 ∧ j ij (xij = tij ), where σ0 is a substitution,   and j ij (xij = tij ) the constraint to be satisfied by σ0 . Definition 3 (Innermost narrowing [16]). Let R be a TRS. A term t ∈ T (F , X ∪ N ) innermost narrows into a term t ∈ T (F , X ∪ N ) at the nonvariable position p of t, using the rule l → r ∈ R with the constrained substitution    σ = σ0 ∧ j∈[1..k] σj , which is written t Inn p,l→r,σ t , iff t = σ0 (t[r]p ), where σ0 is the most general unifier (mgu) of t|p and l and σj , j ∈ [1..k] are all mgus of σ0 t|p and a lhs l of a rule of R, for all suffix position p of p in t. It is always assumed that there is no variable in common between the rule and the term i.e., that V ar(l) ∩ V ar(t) = ∅. In the following, we are only interested in the restriction of the narrowing substitution applied to the current term t. We then omit its definition on the variables of the lhs of rules. Now, we have to see how to simulate the IP -rewriting steps of a given term following the possible instances of its variables, by narrowing it with the rules, considering their priority. Unlike for simulating rewriting without priorities, where the narrowing process only depends on the term to be rewritten and of the rule considered, simulating IP -rewriting of ground instances of a term with a given rule requires to take into account the narrowing steps with the rules having a higher priority. Like for the innermost mechanism of Definition 3, this requires to use negations of substitutions. Let us consider the PRS {f (g(x), y) → a  f (x, h(y)) → b  f (x, y) → c}. The term f (x, y) innermost narrows into a with the first rule and the mgu σ1 = (x = g(x )), into b

Termination of Priority Rewriting

391

with the second rule, the mgu σ2 = (y = h(y  )) and the constraint x = g(x ) (which is the negation of the mgu of σ2 f (x, y) with the lhs of the first rule), and finally into c with the third rule, the mgu σ3 equal to Id and the constraint x = g(x ) ∧ y = h(y  ) (which is the negation of the mgu of σ3 f (x, y) with the first rule and of the mgu of σ3 f (x, y) with the second rule). So, applying the rules one after the other on t, with the current mgu σ, we have to accumulate the negation of the mgus of σt and the previous rules, without their constraint part. We have now to see how to manage together the constraints due to the innermost mechanism and those due to the priority  mechanism. If the narrowing substitutions are in their full form σ0 ∧ j∈[1..k] σj with a constraint part coming from the innermost mechanism of Definition 3, this constraint part is also ignored by the priority mechanism. Indeed, it is defined from σ0 , and has no meaning for the negation of σ0 . With the PRS {f (g(h(x))) → a  h(a) → b  f (g(x)) → c}, the term f (x) innermost narrows into with a the first rule and σ1 = (x = g(h(x )) ∧ x = a), the second rule does not apply, and the third rule applies with σ3 = (x = g(x ) ∧ x = h(x )) (where (x = h(x ) ∧ x = a) is the narrowing substitution of σ3 f (x) with the first rule. Also, if the constraint part of a substitution is due to the priority mechanism, the negation of this substitution by the innermost mechanism also only considers the mgu of the substitution. With the PRS {f (g(h(x, y)), z) → a  f (x, y) → b, h(a, x) → a  h(x, b) → b}, the term f (x, y) innermost narrows into a with the first rule and σ1 = (x = g(h(x , y  )) ∧ x = a ∧ y  = b), because h(x , y  ) narrows with the third rule and σ = (x = a), and with the fourth rule and σ = (y  = b ∧ x = a). Note that the term f (x, y) also innermost narrows into b with the second rule and σ2 = (Id ∧ x = g(h(x , y  ))). Definition 4 (Innermost priority narrowing). Let R be a PRS. A term t ∈ T (F , X ∪ N ) IP -narrows into t ∈ T (F , X ∪ N ) at the non-variable position p of t, using the rule l → r ∈ R with the constrained substitution σ = σ0 ∧   IP   i j∈[1..k] σj i∈[1..n] σ0 , which is written t p,l→r,σ t , iff t = σ0 (t[r]p ), where σ0 is the mgu of t|p and l, σj , j ∈ [1..k] are all mgus of σ0 t|p and a lhs l of a rule of R, for all suffix position p of p in t, and σ0i , i ∈ [1..n] are the mgus of σ0 t|p with the lhs of the rules having a greater priority than l → r. The following lifting lemma ensures that the previously defined narrowing relation simulates IP -rewriting on ground terms. Lemma 1 (Priority Innermost Lifting Lemma). Let R be a PRS. Let s ∈ T (F , X ), α a ground substitution such that αs is IP -reducible at a non variable position p of s, and Y ⊆ X a set of variables such that Var (s) ∪ Dom(α) ⊆ Y. t , then there exist a term s ∈ T (F , X ) and substitutions β, σ = If αs →IP  p,l→r  σ0 ∧ j∈[1..k] σj i∈[1..n] σ0i . such that: 1. 2. 3. 4.

 s IP p,l→r,σ s ,   βs = t , βσ0 = α[Y ∪ V ar(l)]   β satisfies j∈[1..k] σj i∈[1..n] σ0i

392

I. Gnaedig

where σ0 is the mgu of s|p and l and σj , j ∈ [1..k] are all mgus of σ0 s|p and a lhs l of a rule of R, for all suffix position p of p in s, and σ0i , i ∈ [1..n] are the mgus of σ0 s|p with the lhs of the rules having a greater priority than l → r. Accumulating Constraints. Abstraction constraints have to be combined with the narrowing substitutions to characterize the ground terms schematized by the current term t in the proof tree. Indeed, a narrowing step on the current term u with narrowing substitution σ represents a rewriting step for any ground instance of σu. So σ, considered as the narrowing constraint attached to the narrowing step, is added to the abstraction constraint, or in practice, propagated into it by applying its substitution part to the variables of the constraint. Note that if σ does not satisfy the abstraction constraint, the narrowing step is meaningless: it does not correspond to any rewriting step of the considered ground instances. This leads to the introduction of abstraction constraint formulas. Definition 5.  An abstraction constraint formula (ACF in short) is a formula    i (ti ↓ = ti ) ∧ j (xj = uj ), where xj ∈ X ∪ N , ti , ti , uj , ∈ T (F , X ∪ N ). It is satisfiable iff there is at least one instantiation θ such that i (θti ↓ = θti ) ∧  (θx = θu ); θ is then said to satisfy the ACF A and is called solution of A. j j j An ACF A is attached to each term u in the proof trees; the ground substitutions solutions of A define the instances of the current term u, for which we are observing IP -termination. When A has no solution, the current node of the proof tree represents no ground term. Such nodes are then irrelevant for the proof. Detecting and suppressing them during a narrowing step allows us to control the narrowing mechanism, well known to easily diverge. So, we have the choice between generating only the relevant nodes of the proof tree, by testing the satisfiability of A at each step, or stopping the proof on a branch on an irrelevant node, by testing the unsatisfiability of A. The satisfiability of A is in general undecidable, but it is often easy in practice to exhibit an instantiation satisfying it: most of the time, solutions built on constructor terms can be synthesized in an automatic way. Other automatable sufficient conditions, relying in particular on the characterization of normal forms [20], are also under study. The unsatisfiability of A is also undecidable in general, but here also, simple automatable sufficient conditions can be used. In Sect. 5, we present the procedure exactly simulating the rewriting trees i.e., dealing with the satisfiability of A. In Sect. 6, we give the alternative approach dealing with the unsatisfiability, present the sufficient conditions to test it, and show why it is particularly advantageous for IP -rewriting.

5

The IP-Termination Procedure

We are now ready to describe the inference rules defining our proof mechanism. They transform a set T of 3-tuples (U, A, C) where U = {t} or ∅, t is the

Termination of Priority Rewriting

393

current term whose ground instances have to be proved IP -terminating, A is an abstraction constraint formula, C is a conjunction of ordering constraints. Before to give the inference rules, let us note that the inductive reasoning can be completed as follows. When the induction hypothesis cannot be applied to a term u, it may be possible to prove IP -termination of every ground instance of u in another way. Let IPT (u) be a predicate that is true iff every ground instance of u is IP -terminating. In the first and third inference rules, we then associate the alternative predicate IPT (u) to the condition t > u. To establish IPT (u), decidable sufficient conditions exist, applicable in practice, because the predicate is only considered for particular terms introduced along the proof, and not for any term. Simple cases often arise like non narrowable terms of T (F , N ). The notion of usable rules [21,16], is also suitable for proving termination of u and can also be adapted to IP -rewriting. The inference rules are given in Table 1. For a detailed explanation as well as considerations about the predicate IP T and the usable rules, see [19]. We generate the proof trees of R by applying, for each symbol g ∈ D, the inference rules on the initial 3-tuple ({tref = g(x1 , . . . , xm )}, , ) (if g is a constant, then tref = g), with a specific strategy S−RU LES: repeat ∗ (try−skip(Abstract), try−stop(Narrow), try−skip(Stop)). ”repeat ∗ (T1 , . . . , Tn )” repeats the control strategies T1 , . . . , Tn until none of them is applicable anymore, try−skip(T ) expresses that T is tried and skipped when it cannot be applied, try−stop(T ) stops S−RU LES if T cannot be applied. The process may not terminate if there is an infinite number of applications of Abstract and Narrow on the same branch of a proof tree. It may stop on Table 1. Inference rules for IP-termination Abstract:

{u}, A ∧

{t}, A, C t|j ↓ = Xj , C ∧

 j∈{i1 ,...,ip }



HC (t|j )

j∈{i1 ,...,ip }

where t is abstracted into u at positions i1 , . . . , ip =  if C ∧ HC (t|i1 ) . . . ∧ HC (t|ip ) is satisfiable Narrow:

{t}, A, C {vi }, A ∧ σ, C

Stop:

{t}, A, C ∅, A ∧ HA (t), C ∧ HC (t)

if t  IP σ vi and A ∧ σ is satisfiable if (C ∧ HC (t)) is satisfiable.

——————————————– ⎧ ⎨

if t is in T (F, N ) and is not narrowable HA (t) = ⎩ t↓ = X otherwise.

 HC (t) =

 if IPT (t) tref > t otherwise.

394

I. Gnaedig

Abstract (resp. Narrow) when the ordering (resp. abstraction) constraints cannot be proved satisfiable. Nothing can be said in these cases about IP termination. The good case is when all branches of the proof trees end with an application of Stop: then IP -termination is established. A finite proof tree is said to be successful if its leaves are states of the form (∅, A, C). We write SUCCESS (g, ) if the application of S−RU LES on ({g(x1 , . . . , xm )}, , ) gives a successful proof tree, whose sets C of ordering constraints are satisfied by the same ordering . Theorem 1. Let R be a priority term rewrite system on T (F , X ) having at least one constructor constant. Every term of T (F ) is IP -terminating iff there is a noetherian ordering  such that for each g ∈ D, we have SUCCESS (g, ). Examples using the rules of Table 1 can be found in [19], as well as the proofs of Lemma 1 and Theorem 1.

6

Abstraction Constraints for Priority Rewriting

We present in this section an alternative approach to our procedure, dealing with the unsatisfiability of A instead of the satisfiability, and show in comparison why it is suitable for IP -termination. As explained in Sect. 4, instead of testing whether each node generated in the proof tree is relevant i.e., whether A is satisfiable, we test whether we have generated irrelevant nodes, and stop the proof process on the irrelevant nodes. For this, we just have to suppress the satisfiability test of A∧σ in the condition of Narrow, and to add the condition “A is unsatisfiable” as an alternative condition of Stop. Narrow is then applied with try−skip instead of try−stop. In [16], we give automatable sufficient conditions for the unsatifiability of an abstraction constraint t↓ = t , often applicable in practice. As these conditions only work on the equalities of A, dealing with the unsatisfiability of A instead of the satisfiability is of particular interest when A involves many negations of substitutions. Testing the satisfiability instead requires to verify that the solutions of the equational part of A verify its disequality part. Testing the unsatisfiability is precisely advantageous for a succession of priority rules involving more than two or three rules, since narrowing with the nth rule requires to accumulate the negation of n − 1 narrowing substitutions. Moreover, since the unsatisfiability test is an alternative condition of Stop, dealing with the unsatisfiability of A instead of the satisfiability is obviously interesting when Stop applies with the first condition ((C ∧HC (t)) is satisfiable). Analyzing A can then be completely avoided. It is immediate when rules have constant right-hand sides: Narrow then generates constant terms, for which the predicate IP T trivially holds. As said in the introduction, rewriting-based specifications with priorities on rules have recently been used to specify security policies, with a concern of

Termination of Priority Rewriting

395

verification of consistency, termination and completeness. They often have the two characteristics enlightened above. The example we give below has been proposed in [9], for a conference management system described in [22]. Its termination, due to priority arguments, could not be formally proved until now. Example 2. If we do not consider priorities, the following rewrite system is divergent, because of the eighth rule. Let us prove that it is IP -terminating. ⏐ ⏐ aut(q(author(x), SP, pap(x, z)), SU BM IS, u) → P ERM IT ⏐ ⏐ aut(q(author(x), SP, pap(x, z)), v, u) → DEN Y ⏐ ⏐ aut(q(author(x), RSC, pap(x, z)), v, u) → DEN Y ⏐ ⏐ aut(q(rev(x), w, p), v, conf (x, p)) → DEN Y ⏐ ⏐ aut(q(rev(x), SR, pap(y, z)), REV, ass(x, pap(y, z))) → P ERM IT ⏐ ⏐ aut(q(rev(x), SR, pap(y, z)), v, ass(x, pap(y, z))) → DEN Y ⏐ ⏐ aut(q(rev(x), RSC, pap(y, z)), M EE, ass(x, pap(y, z))) → P ERM IT ⏐ ⏐ aut(q(rev(x), w, pap(x, z)), v, u) → aut(q(rev(x), w, pap(x, z)), v, conf (x, pap(x, z))) ⏐

aut(x, y, z) → N AP P LIC .

We apply the strategy S−RU LES on the initial pattern tref = aut(x, y, z). The proof tree is given in Fig. 1. We first have an Abstract step. Then, a Narrow step gives 9 branches, following the 9 above rules. With the constrained narrowing substitutions σ1 , (σ2 ∧ σ21 ), . . . (σ7 ∧ σ71 ∧ . . . ∧ σ76 ) (where σij is the mgu of σi aut(X, Y, Z) with the jth rule), the first seven ones give respectively the states P ERM IT, DEN Y, DEN Y, DEN Y, P ERM IT, DEN Y, P ERM IT , on which Stop then applies. Indeed, we have IP T (P ERM IT ) and IP T ( DEN Y ) since P ERM IT and DEN Y are constructor constants. The ninth branch gives the state N AP P LIC, on which Stop applies too. tref = aut(x, y, z) A = , C =  Abstract



aut(X, Y, Z) A = (x↓ = X, y↓ = Y, z↓ = Z), C = (aut(x, y, z) > x, y, z) Narrow

1 ∧...σ 7 σ8 ∧σ8 8



Rule 8

aut(q(rev(X  ), w, pap(X  , Z  )), Y, conf (X  , pap(X  , Z  ))) A = (x↓ = X, y↓ = Y, z↓ = Z ∧X = q(rev(X  ), w, pap(X  , Z  )) ∧σ1 . . . σ7 ) Narrow

σ10 =Id



Rule 4

DEN Y Stop



∅ Fig. 1. Proof tree for symbol aut

396

I. Gnaedig

The interesting branch is the eighth one, giving the state aut(q(rev(X  ), w, pap(X  , Z  )), Y, conf (X  , pap(X  , Z  ))) with the substitution σ8 = (X = q(rev(X  ), w, pap(X  , Z  ))) constrained by σ81 ∧ . . . σ87 . To lighten the figure, we only specify this branch in the proof tree. From this last state, we still apply Narrow, with three narrowing possibilities: one, with the fourth rule and the substitution σ9 = Id, gives the state DEN Y , on which Stop then applies, because we have IP T (DEN Y ). The two other ones are not valid: using the eighth and the ninth rules, we also have the narrowing substitution Id , which becomes empty once constrained by σ9 . Applying the inference rules dealing with the satisfiability of A would have required to perform the satisfiability test for the nine branches of the first Narrow step, which is avoided here. As one can see, the rule Stop applies on all branches of the proof tree thanks to the predicate IP T . So, on this example, we do not even need to consider A. To satisfy the ordering constraints, any simplification ordering holds. So this example can be treated in a completely automatic way.

7

Conclusion

In this paper, we have proposed an inductive method for proving termination of the decidable innermost priority rewriting relation of C.K. Mohan [11]. This work is an extension to priority rewriting of an inductive approach given in [16] for proving innermost termination of rewriting. In our termination proof technique, the priority mechanism localizes in the specific narrowing relation used to model the rewriting relation on ground terms. Moreover, it can be expressed through negations of substitutions, then introducing constraints similar to those already required to model ground innermost rewriting. We then have generalized the innermost narrowing relation introduced in [16], to model the IP -rewriting relation on ground terms and have given a lifting lemma ensuring the correctness of this modelization. Constraints are crucial in our approach: ordering constraints guarantee the applicability of the induction principle, abstraction constraints define the ground terms considered at each step of the proof, and help to contain the narrowing mechanism. When the treatment of the constraints is automatable – sufficient conditions for ordering constraints as well as for abstraction constraints can be given for this – the proof procedure is completely automatable. Considering unsatisfiability of abstraction constraints instead of satisfiability is, in general, particularly suitable for priority rewriting and more precisely for rule-based security policies. As termination of the original priority rewriting relation of [2] guarantees a semantics for this relation, one can think that IP -termination guarantees a semantics for the IP -rewriting relation. This has to be investigated. We also plan to generalize our technique to the termination proof of other priority rewriting relations, in particular for specifying security policies.

Termination of Priority Rewriting

397

References 1. Baeten, J.C.M., Bergstra, J.A., Klop, J.W.: Term rewriting systems with priorities. In: Lescanne, P. (ed.) RTA 1987. LNCS, vol. 256, pp. 83–94. Springer, Heidelberg (1987) 2. Baeten, J.C.M., Bergstra, J.A., Klop, J.W., Weijland, W.P.: Term-rewriting systems with rule priorities. Theoretical Computer Science 67(2-3), 283–301 (1989) 3. van den Brand, M.G., Klint, P., Verhoef, C.: Term Rewriting for Sale. In: WRLA 1998. ENTCS, vol. 15, pp. 139–161. Elsevier, Amsterdam (1998) 4. Marti-Oliet, N., Meseguer, J., Verdejo, A.: Towards a strategy language for Maude. In: WRLA 2004. ENTCS, vol. 117, pp. 417–441. Elsevier, Amsterdam (2004) 5. Plasmeijer, R., van Eekelen, M.: Functional Programming and Parallel Graph Rewriting. Addison-Wesley, Reading (1993) 6. Augustsson, L.: A compiler for lazy ML. In: LFP 1984, pp. 218–227. ACM, New York (1984) 7. Home of Clean, http://clean.cs.ru.nl/index.html 8. Wiki homepage of Haskell, http://www.haskell.org/haskellwiki/Haskell 9. de Oliveira, A.S.: R´e´ecriture et Modularit´e pour les Politiques de S´ecurit´e. PhD thesis, Univesit´e Henri Poincar´e, Nancy, France (2008) 10. de Oliveira, A.S., Wang, E.K., Kirchner, C., Kirchner, H.: Weaving rewrite-based access control policies. In: FMSE 2007, pp. 71–80. ACM, New York (2007) 11. Mohan, C.K.: Priority rewriting: Semantics, confluence, and conditionals. In: Dershowitz, N. (ed.) RTA 1989. LNCS, vol. 355, pp. 278–291. Springer, Heidelberg (1989) 12. van de Pol, J.: Operational semantics of rewriting with priorities. Theoretical Computer Science 200(1-2), 289–312 (1998) 13. Sakai, M., Toyama, Y.: Semantics and strong sequentiality of priority term rewriting systems. Theoretical Computer Science 208(1–2), 87–110 (1998) 14. van de Pol, J., Zantema, H.: Generalized innermost rewriting. In: Giesl, J. (ed.) RTA 2005. LNCS, vol. 3467, pp. 2–16. Springer, Heidelberg (2005) 15. Moreau, P., Ringeissen, C., Vittek, M.: A Pattern Matching Compiler for Multiple Target Languages. In: Hedin, G. (ed.) CC 2003. LNCS, vol. 2622, pp. 61–76. Springer, Heidelberg (2003) 16. Gnaedig, I., Kirchner, H.: Termination of rewriting under strategies. ACM Transactions on Computational Logic (to appear, 2008), tocl.acm.org/accepted/315gnaedig.ps 17. Baader, F., Nipkow, T.: Term rewriting and all that. Cambridge University Press, Cambridge (1998) 18. Terese: Term Rewriting Systems. Cambridge Tracts in Theoretical Computer Science, vol. 55. Cambridge University Press, Cambridge (2003) 19. Gnaedig, I.: Termination of Priority Rewriting - Extended Version. HAL-INRIA Open Archive Number inria-00349031 (2008) 20. Comon, H., Dauchet, M., Gilleron, R., L¨ oding, C., Jacquemard, F., Lugiez, D., Tison, S., Tommasi, M.: Tree automata techniques and applications (2007) (release October 12th, 2007), http://www.grappa.univ-lille3.fr/tata 21. Arts, T., Giesl, J.: Proving innermost normalisation automatically. In: Comon, H. (ed.) RTA 1997. LNCS, vol. 1232, pp. 157–171. Springer, Heidelberg (1997) 22. Dougherty, D.J., Fisler, K., Krishnamurthi, S.: Specifying and reasoning about dynamic access-control policies. In: Furbach, U., Shankar, N. (eds.) IJCAR 2006. LNCS, vol. 4130, pp. 632–646. Springer, Heidelberg (2006)

State Complexity of Combined Operations for Prefix-Free Regular Languages Yo-Sub Han1 , Kai Salomaa2 , and Sheng Yu3 1

3

Intelligence and Interaction Research Center, KIST P.O.BOX 131, Cheongryang, Seoul, Korea [email protected] 2 School of Computing, Queen’s University Kingston, Ontario K7L 3N6, Canada [email protected] Department of Computer Science, University of Western Ontario London, Ontario N6A 5B7, Canada [email protected]

Abstract. We investigate the state complexity of combined operations for prefix-free regular languages. Prefix-free minimal deterministic finitestate automata have a unique structural property that plays an important role to obtain the precise state complexity of basic operations. Based on the same property, we establish the precise state complexity of four combined operations: star-of-union, star-of-intersection, star-of-reversal and star-of-catenation.

1

Introduction

Regular languages are widely used in many applications such as text searching, speech processing or software engineering [1,2,3]. Given a regular language L, researchers often use the number of states in the minimal DFA for L to represent the complexity of L. Based on this notation, we, then, define the state complexity of an operation for regular languages to be the number of states that are necessary and sufficient in the worst-case for the minimal DFA that accepts the language obtained from the operation [4]. The state complexity of an operation is calculated based on the the structural properties of given regular languages and the function of a given operation. Recently, due to large amount of memory and fast CPUs, many applications using regular languages require huge size of finite-state automata (FAs). This makes the estimated upper bound of the state complexity useful in practice since it is directly related to the efficient resource management in applications. Moreover, it is a challenging quest to verify whether or not an estimated upper bound can be reached. Yu [5] gave a comprehensive survey of the state complexity of regular languages. Salomaa et al. [6] studied classes of languages for which the reversal operation reaches the exponential upper bound. As special cases of the state complexity, researchers examined the state complexity of finite languages [7,8], A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 398–409, 2009. c Springer-Verlag Berlin Heidelberg 2009 

SC of Combined Operations for Prefix-Free Regular Languages

399

the state complexity of unary language operations [9] and the nondeterministic descriptional complexity of regular languages [10]. For regular language codes, Han et al. [11] studied the state complexity of prefix-free regular languages. They tackled the problem based on the structural property of prefix-free DFAs: A prefix-free DFA must be non-exiting assuming all states are useful [11]. Similarly, based on suffix-freeness, Han and Salomaa [12] looked at the state complexity of suffix-free regular languages. There are several other results with respect to the state complexity of different operations [13,14,15,16,17,18]. While people mainly looked at the state complexity of single operations (union, intersection, catenation and so on), Yu and his co-authors [19,20,21] recently started investigating the state complexity of combined operations (starof-union, star-of-intersection and so on). They showed that the state complexity of a combined operation is usually not equal to the composition of the state complexities of the participating individual operations. On the other hand, they also observed that in a few cases, the state complexity of a combined operation is very close to the composition of the state complexities. This leads us to study the state complexity of combined operations and examine the cases that give a similar state complexity to the composition of the state complexities of single operations. We choose prefix-free regular languages for the state complexity of combined operations. Note that state complexity of prefix-free regular languages is very different from the state complexity of regular languages because prefix-freeness gives a unique structural property in a prefix-free minimal DFA [11,22]. Moreover, prefix-free languages are used in many coding theory applications (Huffman coding is an example), and for this reason results on state complexity of combined operations for prefix-free regular languages may be useful. Furthermore, determining the state complexity of combined operations on fundamental subfamilies of the regular languages can provide valuable insights on connections between restrictions placed on language definitions and descriptional complexity. In Section 2, we define some basic notions. Then, we present the state complexities of four combined operations in Section 3. We compare the state complexity of basic operations and the state complexity of combined operations for prefix-free regular languages, and conclude the paper in Section 4.

2

Preliminaries

Let Σ denote a finite alphabet of characters and Σ ∗ denote the set of all strings over Σ. The size |Σ| of Σ is the number of characters in Σ. A language over Σ is any subset of Σ ∗ . The symbol ∅ denotes the empty language and the symbol λ denotes the null string. For strings x, y and z, we say that x is a prefix of y if y = xz. We define a (regular) language L to be prefix-free if for any two distinct strings x and y in L, x is not a prefix of y. Given a string x in a set X of strings, let xR be the reversal of x, in which case X R = {xR | x ∈ X}. An FA A is specified by a tuple (Q, Σ, δ, s, F ), where Q is a finite set of states, Σ is an input alphabet, δ : Q × Σ → 2Q is a transition function, s ∈ Q is the

400

Y.-S. Han, K. Salomaa, and S. Yu

start state and F ⊆ Q is a set of final states. If F consists of a single state f , then we use f instead of {f } for simplicity. Given a DFA A, we assume that A is complete; namely, each state has |Σ| out-transitions and, therefore, A may have a sink state. We assume that A has a unique sink state since all sink states are equivalent and can be merged into a single state. Let |Q| be the number of states in Q. The size |A| of A is |Q|. For a transition δ(p, a) = q in A, we say that p has an out-transition and q has an in-transition. Furthermore, p is a source state of q and q is a target state of p. We say that A is non-returning if the start state of A does not have any in-transitions and A is non-exiting if all out-transitions of any final state in A go to the sink state. A string x over Σ is accepted by A if there is a labeled path from s to a final state such that this path reads x. We call this path an accepting path. Then, the language L(A) of A is the set of all strings spelled out by accepting paths in A. We say that a state of A is useful if it appears in an accepting path in A; otherwise, it is useless. Unless otherwise mentioned, in the following we assume that all states are useful. A regular expression E is prefix-free if L(E) is prefix-free and an FA A is prefix-free if L(A) is prefix-free. Moreover, if L(A) is prefix-free, then A must be non-exiting. We recall that an arbitrary minimal DFA recognizing a prefix-free language has exactly one final state and all of its out-transitions go to the sink state [11]. For complete background knowledge in automata theory, the reader may refer to the textbook [23].

3

State Complexity of Combined Operations

We consider four combined operations of prefix-free regular languages: starof-union, star-of-reversal, star-of-catenation and star-of-intersection. For each operation, we compare the state complexity of a combined operation and the composition of the state complexities of two individual operations. In the following section, let SC(L) denote the state complexity of L. 3.1

Star of Union

First we give an upper bound construction for the state complexity of star-ofunion of two prefix-free languages. Let Ai = (Qi , Σ, δi , q0,i , fi ), |Qi | = mi , i = 1, 2 be arbitrary minimal DFAs recognizing prefix-free languages. Here fi ∈ Qi is the unique final state and we can assume that fi = qi,0 . (If the final state is the start state, Ai must recognize {λ}.) We denote by di ∈ Qi the sink state of Ai , Qi = Qi \ {fi , di } is the set of states of Ai excluding the final state and the sink state. Without loss of generality we assume that Q1 ∩ Q2 = ∅. We construct a DFA A = (Q, Σ, δ, {q0, q0,1 , q0,2 }, F )

(1)

SC of Combined Operations for Prefix-Free Regular Languages

401

for the language (L(A1 ) ∪ L(A2 ))∗ . We choose Q to be the collection of subsets of P ⊆ {q0 } ∪ Q1 ∪ Q2 such that if q0 ∈ P, then q0,1 , q0,2 ∈ P.

(2)

The set of final states F consists of all elements of Q that contain q0 and the transition function δ is defined as follows. Let P = X ∪ P1 ∪ P2 , where Pi ⊆ Qi , i = 1, 2, X is {q0 } or ∅, and c ∈ Σ. Then we define:  δ1 (P1 , c) ∪ δ2 (P2 , c), if f1 ∈ δ1 (P1 , c) and f2 ∈ δ2 (P2 , c), δ(P, c) = δ1 (P1 , c) ∪ δ2 (P2 , c) ∪ {q0,1 , q0,2 , q0 }, otherwise. The transitions defined above clearly preserve the property (2), that is, for any P ∈ Q, δ(P, c) ∈ Q. The construction of A can be viewed as constructing an NFA for the starof-union of the original languages, and performing a subset construction on the NFA. In the subset construction, we can merge the final states of the original DFAs. The construction is illustrated in Fig. 1. Σ Σ

q0,1

A1

Σ

d1 q0,1

f1

Σ

d1

Σ

d2

A1 q0

q0,2

A2

q0,2

f2 Σ

d2 Σ

A2 Σ

Fig. 1. Construction of an NFA for the star-of-union. Note that the merged state q0 , which is a final state as well, is the start state.

The DFA A uses the symbol q0 to represent the merging of the two final states f1 and f2 of the original DFAs. The start state of A is {q0 , q0,1 , q0,2 } which means that the computation begins by simulating both the computation of A1 and the computation of A2 . Whenever one of the simulated computations enters the final state, the computation of A adds both q0,1 and q0,2 to the current set of states and begins new computations simulating A1 and A2 . Namely, q0 in the current set indicates that the previously simulated computation step is accepted either in A1 or in A2 . Note that the presence of q0,1 or q0,2 in the current state of A is not sufficient to guarantee this property. The choice of the final states guarantees that A recognizes exactly the language (L(A1 ) ∪ L(A2 ))∗ . Assuming, q0,i , fi , and di are all distinct, for i = 1, 2, the set Q of states defined by (2) contains 2m1 +m2 −4 subsets of Q1 ∪ Q2 that do not contain the

402

Y.-S. Han, K. Salomaa, and S. Yu

merged final state q0 . Additionally, Q contains 2m1 +m2 −6 subsets of the form {q0 , q0,1 , q0,2 } ∪ P where P ⊆ (Q1 \ {q0,1 , f1 , s1 }) ∪ (Q2 \ {q0,2 , f2 , s2 }). Note that if q0,i , fi and di , i ∈ {1, 2}, are not distinct, then Ai recognizes one of the trivial languages {λ} or ∅. Now we obtain the following upper bound for the state complexity of star-ofunion of prefix-free regular languages from the construction. Lemma 1. Let Li be a prefix-free regular language with SC(Li ) = mi , mi ≥ 3, i = 1, 2. Then SC((L1 ∪ L2 )∗ ) ≤ 5 · 2m1 +m2 −6 . In the following, we give a worst-case construction that reaches the upper bound of Lemma 1. Let Σ = {a, b, c, d, e} and m, n ≥ 3. We define A1 = (R, Σ, δ1 , r0 , {rm−2 }),

(3)

where R = {r0 , . . . , rm−1 }, and the transitions of δ1 are defined as: – δ1 (ri , a) = ri+1 , i = 0, . . . , m − 4, δ1 (rm−3 , a) = r0 . – δ1 (ri , b) = δ1 (ri , d) = ri , i = 0, . . . , m − 3. – δ1 (r0 , c) = rm−2 , δ1 (ri , c) = ri , i = 1, . . . , m − 3. The state rm−1 is the sink state of A1 and above all undefined transitions go to rm−1 . In particular, note that all transitions of A1 on input symbol e go to the sink state. The language L(A1 ) is prefix-free since all out-transitions from the final state rm−2 go to the sink state. We define the second DFA as A2 = (S, Σ, δ2 , s0 , {sn−2 }),

(4)

where S = {s0 , . . . , sn−1 }, and δ2 is defined by setting: – δ2 (si , b) = si+1 , i = 0, . . . , n − 4, δ2 (sn−3 , b) = s0 . – δ2 (si , a) = δ2 (si , e) = si , i = 0, . . . , n − 3. – δ2 (s0 , c) = sn−2 , δ2 (si , c) = si , i = 1, . . . , n − 3. Again, sn−1 is the sink state of A2 and all above undefined transitions go to the sink state. In particular, any state of A2 transitions with input symbol d to the sink state. The DFAs A1 and A2 are depicted in Fig. 2. We show that the DFAs in Fig. 2 reach the upper bound of Lemma 1 when m, n ≥ 3. Note that any complete DFA recognizing a prefix-free language that is not {λ} or ∅ has to have at least three states. Lemma 2. Let m, n ≥ 3 and let A1 and A2 be DFAs as defined in (3) and (4), respectively. We claim that SC((L(A1 ) ∪ L(A2 ))∗ ) is 5 · 2m+n−6 . By Lemmas 1 and 2 we get a precise bound for the state complexity of star-ofunion of prefix-free regular languages.

SC of Combined Operations for Prefix-Free Regular Languages

b, c, d b, d

a

r1

a, c, e

b, c, d

a

r2

a

a, e

a

rm−3

c a

rm−2

s1

a, c, e

b

s2

b

s0

r0 c

b

403

b, c, d

sn−2

b

sn−3

b a, c, e

Fig. 2. The DFAs A1 and A2 . The figure does not show the sink states rm−1 and sn−1 and their in-transitions.

Theorem 1. The worst-case state complexity of the star-of-union of an m1 state and an m2 -state, m1 , m2 ≥ 3, prefix-free regular languages is precisely 5 · 2m1 +m2 −6 , where |Σ| ≥ 5. Theorem 1 implies that the upper bound can be reached for all values m1 , m2 ≥ 3. If, for example, m2 = 2, the state complexity is m1 . The result follows from the state complexity of star for prefix-free languages [11] because with m2 = 2, the worst-case example corresponds to the case where L(A2 ) = {λ} and (L(A1 ) ∪ L(A2 ))∗ = L(A1 )∗ . Note that the state complexity of the union of two prefix-free regular languages is m1 m2 − 2 [11] and the state complexity of the star of an m-state regular language is 3 · 2m−2 [4]. Thus, the composition of two complexities is 3 · 2m1 m2 −4 . Therefore, the state complexity of the star-of-union is much lower (one has a linear exponent and the other has a quadratic exponent) than the composition of two complexities. The lower bound construction of Lemma 2 uses an alphabet of size five. It remains an open question whether the worst-case bound can be reached by prefixfree regular languages over alphabets of size 2, 3 or 4. 3.2

Star of Reversal

Let A be a minimal DFA for a regular language and |A| = m. Since the state complexity of L(A) is m, the reversal L(A)R of L(A) can be accepted by an NFA AR with m states, where AR can have multiple start states. We, then, use the subset construction on AR and the resulting DFA can have at most 2m states. Thus, the upper bound for the reversal of regular languages is 2m . Leiss [24] demonstrated that some classes of languages can reach the upper bound. Later, Salomaa et al. [6] showed the conditions for such regular languages and obtained the following result. Proposition 1 (Salomaa et al. [6]). Let Σ be an alphabet with at least 2 characters. There exists a minimal DFA A that has a maximal blow-up, 2m , in the transition to its reversal L(A)R , where the transition function of A is functionally complete, L(A) = ∅, Σ ∗ and m = |A|.

404

Y.-S. Han, K. Salomaa, and S. Yu

Given a minimal prefix-free DFA A = (Q, Σ, δ, s, f ), we can obtain an FA for L((A)R )∗ as follows: We first flip all transition directions in A such that f is the start state and s is the final state. Then, the resulting FA AR = (Q, Σ, δ R , f, s) is the reversal of A; L(A)R = L(AR ). The sink state d of A is now unreachable from f in AR and, thus, we remove it. Next, we add all out-transitions of f to s and make f to be final in AR . Note that we keep original out-transition of s in AR as well. Therefore, we have an FA A = (Q \ {d}, Σ, δ  , f, {s, f }), where  R δ (q, a) if q = s,  δ (q, a) = δ R (q, a) ∪ δ R (f, a) otherwise. It is clear from the construction that L(A ) = L((A)R )∗ . Note that A is not necessarily deterministic since we have flipped transition directions. Fig. 3 illustrates this construction. Σ Σ

s

f

Σ Σ

d s

d

f

Fig. 3. Construction of an NFA for the star-of-reversal

Lemma 3. Let L be a prefix-free regular language with SC(L) = m. Then, SC((LR )∗ ) ≤ 2m−2 + 1. Next, we demonstrate that 2m−2 + 1 states are necessary for the star-of-reversal of an m-state prefix-free regular language L. Given a (regular) language L over Σ, L# is prefix-free if the character # is not in Σ. Our approach is an extension of the method used by Han et al. [11] for computing the reversal of prefix-free minimal DFAs. Let A = (Q, Σ, δ, s, F ) be a minimal DFA in Proposition 1 over Σ, which is not prefix-free in general. We construct a prefix-free minimal DFA A# = (Q , Σ ∪ {#}, δ  , s, f  ) that requires m states as follows: Q = Q ∪ {d, f  }, for q ∈ Q and a ∈ Σ ∪ {#}, ⎧ ⎨ δ(q, a) if q ∈ Q and a = #, δ  (q, a) = f  if q ∈ F and a = #, ⎩ d otherwise. Namely, we introduce a new final state f  and connect all states in F of A to f  with label #. We also introduce a sink state d. Since A is functionally

SC of Combined Operations for Prefix-Free Regular Languages

405

complete, that is, the transition function of A consists of all mappings from Q to Q, A cannot have a sink state, and consequently, d is not equivalent with any of the states of A. Note that by the construction, A# is deterministic and minimal. Furthermore, L(A# ) is prefix-free. Thus, if A has m − 2 states, then A# has m states. Proposition 2 (Han et al. [11]). Given a prefix-free minimal DFA A# as constructed above, 2m−2 +1 states are necessary for the minimal DFA of L(A# )R , / Σ. where m = |A# | and # ∈

s

minimal DFA for L(AR )

s

#

s

minimal DFA for L(A#)R

Fig. 4. Construction of the minimal DFA for L(A# )R from the minimal DFA for L(AR ). Note that the left DFA is defined over Σ and the right DFA is defined over Σ ∪ {#}.

The brief sketch of Proposition 2 is that we flip the transition directions of A and apply the subset construction on AR . Let s be the start state of the resulting DFA. Then, we introduce a new start state s and connect s to s with label #. Then, the new FA is the minimal DFA for L(A# )R and the number of states is 2m−2 + 1 if |A| = m − 2. See Fig. 4. We are ready to compute the star-of-reversal for A# . From the minimal DFA M = (Q, Σ, δ, s , F ) for L(A# )R as depicted in Fig. 4, we add #-transitions from all final states in F to s , which is the only target state of s except for the sink state d. We also make s to be a final state. Let M# be the resulting FA. It is easy to verify that L(M# ) = (L(A# )R )∗ . We only need to show that M# is a minimal DFA. Since δ(f, #) = d for f ∈ F in M , M# is deterministic. We show that all states of M# are pairwise inequivalent. First consider two nonfinal states of M# , r1 and r2 . Now since r1 and r2 are inequivalent as states of M , there exists w ∈ Σ ∗ such that δ(r1 , w) ∈ F and δ(r2 , w) ∈ / F . Note that since r1 and r2 are distinct from s , we can assume that w does not contain occurrences of #, and the same string w distinguishes r1 and r2 as states of M# . Next, consider two final states of M# . If they are both also final states in M , then we can use the same argument as above. It remains to show that s is not equivalent with any other final state r of M# . We note that since the original DFA A is functionally complete, r must have an out-transition on a symbol of Σ to some state of Q. On the other hand, the only out-transition from s (either in M or M# ) whose target state is not the sink state d is on the input symbol #. This means that s and r are inequivalent. Therefore, M# is minimal.

406

Y.-S. Han, K. Salomaa, and S. Yu

Note that, from M , we have constructed the minimal DFA for the star-ofreversal of A# without adding new states. This implies that we get a precise bound for the state complexity of star-or-reversal of prefix-free regular languages. Theorem 2. The worst-case state complexity of the star-of-reversal of an mstate prefix-free regular language is precisely 2m−2 + 1, where |Σ| ≥ 3. Note that the state complexity of the reversal of an m-state prefix-free regular language is 2m−2 +1 [11] and the state complexity of the star of an m-state suffixfree regular language is 2m−2 + 1 [12]. Thus, the composition of two complexities m−2 +1−2 is 22 + 1. Therefore, the state complexity of the star-of-reversal is much lower than the composition of two complexities. 3.3

Star of Catenation and Intersection

We examine two operations, star-of-catenation and star-of intersection, based on the following observations: 1. Prefix-freeness is preserved by catenation and intersection. 2. Given an m-state prefix-free DFA A, SC(L(A)∗ ) = m [11]. Theorem 3. The worst-case state complexity of the star-of-catenation of an m1 -state and an m2 -state, m1 , m2 ≥ 3, prefix-free regular languages is precisely m1 + m2 − 2. Theorem 3 shows that the state complexity of the star-of-catenation is equal to the state complexity calculated by the composition of state complexities of star and catenation. This is due to the fact that prefix-freeness is closed under catenation. Since prefix-freeness is also closed under intersection, we expect to see a similar case for the state complexity of the star-of-intersection. Theorem 4. The worst-case state complexity of the star-of-intersection of an m1 -state and an m2 -state, m1 , m2 ≥ 3, prefix-free regular languages is precisely m1 m2 − 2(m1 + m2 ) + 6, where |Σ| ≥ 4. Proof. Han et al. [11] gave a construction for the intersection of two prefix-free DFAs based on the Cartesian product of states. The main idea of the construction is to remove unreachable states and merge equivalent states that are identified based on the structural properties of prefix-free DFAs. Based on the construction, they showed that m1 m2 −2(m1 +m2 )+6 states are sufficient for the intersection of an m1 -state prefix-free minimal DFA and an m2 -state prefix-free minimal DFA. Since prefix-freeness is closed under intersection, the resulting minimal DFA is also prefix-free. Therefore, m1 m2 − 2(m1 + m2 ) + 6 states are sufficient for the star-of-intersection since the state complexity of the Kleene star is m for an m-state prefix-free minimal DFA [11]. We only need to prove the necessary part. Assume that Σ = {a, b, c, d}. Given a string w over Σ, let |w|a denote the number of a’s in w. Let A1 be the minimal DFA for L(A1 ) = {wc | |w|a ≡ 0 (mod m1 − 2), for w ∈ {a, b}∗}

SC of Combined Operations for Prefix-Free Regular Languages

407

and A2 be the minimal DFA for L(A2 ) = {wc | |w|b ≡ 0 (mod m2 − 2), for w ∈ {a, b}∗}. It is easy to verify that L(A1 ) and L(A2 ) are prefix-free and |A1 | = m and |A2 | = n. Let L = (L(A1 )∩L(A2 ))∗ . We claim that the minimal DFA for L needs mn − 2(m + n) + 6 states. To prove the claim, it is sufficient to show that there exists a set R of mn − 2(m + n) + 6 strings over Σ that are pairwise inequivalent modulo the right invariant congruence of L, ≡L . Let R = R1 ∪ R2 , where R1 = {λ, d}, R2 = {ai bj | 1 ≤ i ≤ m1 − 2 and 1 ≤ j ≤ m2 − 2}. Any string ai bj from R2 cannot be equivalent with λ since ai bj ·λ ∈ / L but λ·λ ∈ L. Similarly, ai bj cannot be equivalent with d since ai bj · am1 −2−i bm2 −2−j c ∈ L but d · am1 −2−i bm2 −2−j c ∈ / L. Note that λ and d are not equivalent as well. Next, consider two distinct strings ai bj and ak bl from R2 . Since ai bj = ak bl , ai bj · am1 −2−i bm2 −2−j c ∈ L but ak bl · am1 −2−i bm2 −2−j c ∈ / L. Therefore, any two distinct strings from R2 are pairwise inequivalent. Therefore, all mn − 2(m + n) + 6 strings in R are pairwise inequivalent. This concludes the proof. 

4

Conclusions

Recently, researchers started looking at state complexity of combined operations [19,25,26]. Usually, we can obtain a much lower state complexity for combined operations compared with the composition of state complexities of individual operations. However, in a few cases, the state complexity of combined operations and the composition of state complexities are similar. We have examined prefix-free regular languages and computed the state complexity of combined operations. operation complexity operation complexity ∗ L1 ∪ L2 m1 m2 − 2 (L1 ∪ L2 ) 5 · 2m1 +m2 −6 ∗ L1 ∩ L2 m1 m2 − 2(m1 + m2 ) + 6 (L1 ∩ L2 ) m1 m2 − 2(m1 + m2 ) + 6 L1 · L2 m1 + m2 − 2 (L1 · L2 )∗ m1 + m2 − 2 R m1 −2 ∗ L1 2 +1 (LR 2m1 −2 + 1 1) ∗ ∗ ∗ ∗ m1 (L1 ) = L1 m1 L1 The table summaries the state complexity of basic operations and the state complexity for combined operations of prefix-free regular languages. Note that prefix-freeness is closed under both intersection and catenation and both operations have the same state complexity. On the other hand, for union, the state complexity of the star-of-union is much lower. An interesting case is the reversal case. We know that prefix-freeness is not closed under reversal since the reversal of a prefix-free language is suffix-free. However, the complexities of single and combined operations are the same. We think this is because suffix-free minimal

408

Y.-S. Han, K. Salomaa, and S. Yu

DFAs preserve a certain structural property. Therefore, natural future work is to examine the state complexity of combined operations for suffix-free regular languages.

References 1. Friedl, J.E.F.: Mastering Regular Expressions. O’Reilly & Associates, Inc., Sebastopol (2002) 2. Harel, D., Politi, M.: Modeling Reactive Systems with Statecharts: The Statemate Approach. McGraw-Hill, New York (1998) 3. Karttunen, L.: Applications of finite-state transducers in natural language processing. In: Yu, S., P˘ aun, A. (eds.) CIAA 2000. LNCS, vol. 2088, pp. 34–46. Springer, Heidelberg (2001) 4. Yu, S., Zhuang, Q., Salomaa, K.: The state complexities of some basic operations on regular languages. Theoretical Computer Science 125(2), 315–328 (1994) 5. Yu, S.: State complexity of regular languages. Journal of Automata, Languages and Combinatorics 6(2), 221–234 (2001) 6. Salomaa, A., Wood, D., Yu, S.: On the state complexity of reversals of regular languages. Theoretical Computer Science 320(2-3), 315–329 (2004) 7. Cˆ ampeanu, C., Culik II, K., Salomaa, K., Yu, S.: State complexity of basic operations on finite languages. In: Boldt, O., J¨ urgensen, H. (eds.) WIA 1999. LNCS, vol. 2214, pp. 60–70. Springer, Heidelberg (2001) 8. Han, Y.S., Salomaa, K.: State complexity of union and intersection of finite languages. International Journal of Foundations of Computer Science 19(3), 581–595 (2008) 9. Pighizzini, G., Shallit, J.: Unary language operations, state complexity and Jacobsthal’s function. International Journal of Foundations of Computer Science 13(1), 145–159 (2002) 10. Holzer, M., Kutrib, M.: Nondeterministic descriptional complexity of regular languages. International Journal of Foundations of Computer Science 14(6), 1087–1102 (2003) 11. Han, Y.S., Salomaa, K., Wood, D.: State complexity of prefix-free regular languages. In: Proceedings of DCFS 2006, pp. 165–176 (2006); Full version is submitted for publication 12. Han, Y.S., Salomaa, K.: State complexity of basic operations on suffix-free regular languages. In: Kuˇcera, L., Kuˇcera, A. (eds.) MFCS 2007. LNCS, vol. 4708, pp. 501–512. Springer, Heidelberg (2007) 13. Cˆ ampeanu, C., Salomaa, K., Yu, S.: Tight lower bound for the state complexity of shuffle of regular languages. Journal of Automata, Languages and Combinatorics 7(3), 303–310 (2002) 14. Domaratzki, M.: State complexity of proportional removals. Journal of Automata, Languages and Combinatorics 7(4), 455–468 (2002) 15. Domaratzki, M., Salomaa, K.: State complexity of shuffle on trajectories. Journal of Automata, Languages and Combinatorics 9(2-3), 217–232 (2004) 16. Hricko, M., Jir´ askov´ a, G., Szabari, A.: Union and intersection of regular languages and descriptional complexity. In: Proceedings of DCFS 2005, pp. 170–181 (2005) 17. Jir´ asek, J., Jir´ askov´ a, G., Szabari, A.: State complexity of concatenation and complementation of regular languages. In: Domaratzki, M., Okhotin, A., Salomaa, K., Yu, S. (eds.) CIAA 2004. LNCS, vol. 3317, pp. 178–189. Springer, Heidelberg (2005)

SC of Combined Operations for Prefix-Free Regular Languages

409

18. Nicaud, C.: Average state complexity of operations on unary automata. In: Kutylowski, M., Wierzbicki, T., Pacholski, L. (eds.) MFCS 1999. LNCS, vol. 1672, pp. 231–240. Springer, Heidelberg (1999) 19. Gao, Y., Salomaa, K., Yu, S.: The state complexity of two combined operations: Star of catenation and star of reversal. Fundamenta Informaticae 83(1-2), 75–89 (2008) 20. Salomaa, A., Salomaa, K., Yu, S.: State complexity of combined operations. Theoretical Computer Science 383(2-3), 140–152 (2007) 21. Salomaa, K., Yu, S.: On the state complexity of combined operations and their estimation. International Journal of Foundations of Computer Science 18, 683–698 (2007) 22. Berstel, J., Perrin, D.: Theory of Codes. Academic Press, Inc., London (1985) 23. Wood, D.: Theory of Computation. John Wiley & Sons, Inc., New York (1987) 24. Leiss, E.L.: Succinct representation of regular languages by boolean automata. Theoretical Computer Science 13, 323–330 (1981) 25. Ellul, K., Krawetz, B., Shallit, J., Wang, M.W.: Regular expressions: New results and open problems. Journal of Automata, Languages and Combinatorics 9, 233– 256 (2004) 26. Rampersad, N.: The state complexity of L2 and Lk . Information Processing Letters 98(6), 231–234 (2006)

Towards a Taxonomy for ECFG and RRPG Parsing Kees Hemerik Dept. of Mathematics and Computer Science Eindhoven University of Technology Eindhoven, The Netherlands [email protected]

Abstract. Extended Context-Free Grammars (ECFGs) and Regular Right-Part Grammars (RRPGs) have many applications, but they are sparsely covered in the vast literature on parsing and grammars. This paper presents first steps towards a taxonomy of parsers for ECFGs and RRPGs, in order to make this subject more accessible.

1

Introduction

Extended Context-Free Grammars (ECFGs) and Regular Right-Part Grammars (RRPGs) are two common extensions of Context-Free Grammars (CFGs) with many applications. In computer science they are quite popular as formalisms for describing programming languages, often in the forms of EBNF (Extended Backus-Naur Form) [1] and syntax diagrams. There even exists an ISO standard for EBNF [2]. In computational linguistics, they often appear in the form of transition networks [3,4,5,6]. In spite of their importance for practical language definitions and tools, they are but sparsely covered in the vast literature on grammars and parsing. To the best of our knowledge, there does not exist a uniform, coherent treatment of the subject of ECFGs, RRPGs, and their parsers. Taxonomies, in a precise technical sense, are an effective means of presenting such a subject. A taxonomy is a systematic classification of problems and solutions in a particular (algorithmic) problem domain.Taxonomies also are a good starting point for the construction of highly coherent algorithm toolkits. In the past, taxonomies and/or toolkits of this kind have been constructed for sorting [7,8], garbage collection [9], string pattern matching, finite automata construction and minimization [10,11], and, recently, acceptors and pattern matchers for regular trees [12,13]. In this paper we present first steps towards a taxonomy of parsers for ECFGs and RRPGs. Roughly, the field can be subdivided into four subfields, viz. recursive descent, LL-like, LR-like, and tabular parsing. We outline a taxonomy of recursive descent parsing for ECFGs, present a literature overview for LRparsing of ECFGs and RRPGs, and briefly comment on the other two subfields. In doing so, we hope to make the subject more accessible to interested readers. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 410–421, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Towards a Taxonomy for ECFG and RRPG Parsing

2

411

Definitions

We only outline definitions of some of the main notions. An extended context-free grammar (ECFG) is a 4-tuple (N, P, T, S), where N and T are finite sets of nonterminals and terminals, S  N is the start symbol, and P (the productions) is a map from N to regular expressions over alphabet N ∪T . Similarly, a Regular Right Part Grammar (RRPG) is a 4-tuple (N, P, T, S), where P is a map from N to finite automata over alphabet N ∪ T . Both grammar kinds have productions with right parts which are regular languages over N ∪ T . The language generated by such a grammar can be defined in different ways: – Using the standard derivation notions for CFGs, but with the possibly infinite sets of production rules of the ECFG or RRPG; – Defining a rewrite system for regular expressions, with expressions in T ∗ as normal forms [14]; – Defining ECFG trees (i.e. trees in which each node is labeled with a subexpression of the ECFG and has a number of sons matching the label), and taking the frontiers of these trees [15]; – By interpreting the ECFG as a set of regular language equations and taking the least solution w.r.t. the pointwise subset ordering. It is obvious that each ECFG or RRPG can be transformed into a CFG by transforming each right part to a context-free sub-grammar. Heilbrunner [16] defines two such transformations - called LL(1) transformation and unambiguous right-linear transformation - and uses these to define the ELL(k) and ELR(k) grammars as follows: – An ECFG is an ELL(k) grammar if there is an LL(1) transformation yielding an LL(k) grammar; – An ECFG is an ELR(k) grammar if there is an unambiguous right-linear transformation yielding an LR(k) grammar.

3

Recursive Descent

Recursive descent is a technique for implementing a parser in the form of a recursive program. Taking a few notational shortcuts, the most basic recursive descent scheme can be described as follows. Let G = (N, T, P, S) be an ECFG, with P = {A1 = e1 , · · · , An = en }. P is mapped to the following set of procedure declarations: proc A1 = E[[e1 ]] .. . proc An = E[[en ]]

412

K. Hemerik

where the function E, which maps regular expressions over N ∪ T to statements, is defined recursively as: re E[[re]] ε skip a term(a) A A e1 • · · · • en E[[e1 ]]; · · · ; E[[en ]] e1 | · · · | en if sym  LA(e1 ) → E[[e1 ]] [] · · · [] sym  LA(en ) → E[[en ]] fi e∗ do sym  FIRST (e) → E[[e]] od In this scheme, variable sym is the lookahead symbol, procedure term(a) checks whether sym equals terminal a and, if so, advances sym to the next input symbol, and functions LA and FIRST yield ELL(1) first sets and lookahead sets respectively. Recursive descent is a well-known and popular technique. Its origins are hard to trace. One of the oldest written accounts is given by Lucas in [17]. Conway [3] seems to have been the first to apply it to transition networks, which are essentially RRPGs. Recursive descent occurs in many textbooks on compilers, usually in the form of examples, but there exist only few publications describing general schemes. The most notable are: – Wirth describes in several places (e.g.[18], ch.5) how syntax diagrams can be mapped to Pascal programs; – Lewi and his co-workers [19,15] give detailed accounts of translation schemes (some of them including error recovery) from ECFGs to Ada-like code; – Wilhelm and Maurer ([14], ch.8) give translation schemes for ECFGs, based on dotted rules. 3.1

Sub-taxonomy for Recursive Descent

Although the basic scheme for recursive descent is well-understood, in practice there exist many variations, depending a.o. on which of the following aspects are taken into account: Grammar processing. We can distinguish between interpreting parsers – which are fixed recursive procedures that take a grammar element as a parameter and try to recognize a terminal production of that grammar element – and generated parsers, which are sets of grammar specific recursive procedures, generated by a parser generator. The choice between the two kinds is one of flexibility vs. speed. Handling of alternatives. We distinguish various strategies: Deterministic. In this case the grammar should satisfy the ELL(k) condition, which allows choices to be resolved by k-symbol lookahead; Limited backtrack. In this case all alternatives are pursued, but the parser stops at the first success;

Towards a Taxonomy for ECFG and RRPG Parsing

413

Full backtrack. In this case all alternatives are pursued completely, resulting in sets of solutions. Additional tasks. Parsing is rarely done for its own sake. Usually it is combined with other tasks, such as tree construction or transduction from input to output language. Error handling. Some options are: abortion, graceful termination, error recovery, and error correction. Optimizations. E.g. memoization to make backtracking practically feasible. Based on these details, it is possible to develop a sub-taxonomy for recursive descent parsing of ECFGs. We are currently working on this sub-taxonomy. Some results have been reported in [20,21]. Figure 1 shows the taxonomy graph. All parsers in this taxonomy have been described in an abstract notation of the kind commonly found in texts on algorithms or programming methods. An example of this style is given in Appendix A.

Fig. 1. A taxonomy diagram of the family of recursive descent parsers. The diagram has been taken from [20]. The numbers in the diagram refer to corresponding sections in that document.

4

LL-Like Parsers

Little has been published about LL-like push-down automata for ECFGs. A classical LL-parser for an ordinary CFG (N, T, P, S) is a push-down automaton with a stack alphabet corresponding (roughly) to N ∪ T . A terminal on top of the stack is matched away against the lookahead symbol; a nonterminal on top of the stack is replaced by one of its right-hand sides. The actions are determined by a parse-table indexed by the top-of-stack symbol and the lookahead symbol.

414

K. Hemerik

This model can simply be generalized to ECFGs by using stack symbols which are dotted production rules, and modifying the transition relation accordingly. Wilhelm and Maurer ([14], ch.8) give the construction in full detail. A somewhat different approach is taken by Br¨ uggemann-Klein and Wood [22,23]. In their proposal the stack is not present explicitly, but represented by the list of uncompleted subtrees of the partial parse tree that is being built up.

5

LR-Like Parsers

In this section we consider parsing methods for RRPGs which are adaptations or generalizations of LR-like parsers for CFGs. Conventional LR-like parsers are of the shift-reduce type; they work on a stack and an input stream by means of two operations: a shift operation, which removes a symbol from the input and pushes a state on the stack, and a reduce operation by a specified production, which pops a number (dependent on the production) of states from the stack and pushes a new state on the stack. The top state and lookahead symbols determine which action to take. The actions are encoded in parse tables indexed by states and lookahead symbols. Because RRPGs may lead to derivations with production right parts of unbounded lengths, determining the number of states to pop (the length of the handle) becomes a problem. In the literature the following main approaches to this problem can be distinguished: 1. Transform the RRPG to an equivalent CFG and apply standard techniques for constructing an LR parser [24,16,25]; 2. Use the RRPG directly to construct an LR-like parser, extended with a mechanism to read back into the stack to determine the left end of the handle [26,27,28,29,25]; 3. Use the RRPG to construct a shift-reduce parser which only pushes a state if it may correspond to the beginning of a production and only pops one state upon reduction [30,31,32,33,34,35]; 4. Embedding of some of the techniques mentioned above in different frameworks for LR-like parsing [36,37]. In the following four subsections we will elaborate these approaches. 5.1

Transformation of RRPG to CFG

As already indicated in Section 2, any RRPG can be transformed into a CFG by replacing each right part by a context-free sub-grammar. This suggests one way of solving the parsing problem for RRPGs: first transform to an equivalent CFG, and then use any parsing method for CFGs. There are some disadvantages to such an approach, however: choosing an unsuitable transformation may result in a CFG with undesirable parsing properties. Also, it may be difficult to relate the structure of the input under the new CFG to the structure according to the original ECFG. The following papers discuss some transformations:

Towards a Taxonomy for ECFG and RRPG Parsing

415

– Heilbrunner [16] is concerned with the definition of the notions of ELL(k) and ELR(k) grammar. To this end he uses certain transformations from ECFG to CFG, as we have already outlined in Section 2. – Madsen and Christensen [25] transform an ECFG to a CFG by replacing each right part by an equivalent right-linear subgrammar. They use this transformation to define their ELR(k) notion. Heilbrunner [16] shows that an ECFG is ELR(k) according to this notion iff it is unambiguous and ELR(k) according to his own notion. – Celentano [24] gives a transformation from an ECFG to an equivalent CFG and uses this transformation as the basis for describing the construction of an LR-like parser for an ECFG, which simulates a conventional LR parser for an equivalent CFG. 5.2

LR-Parsers with Readback

The main problem with LR-like parsers for RRPGs is to locate the left end of the handle on the stack. It is not sufficient to construct a DFA (deterministic finite automaton) for each production A → e to recognize the reverse of the language of e. Instead, the LR-parser can be extended with readback automata, which can be constructed to recognize the reverse of the sequences of states entered by the LR-automaton as it reads strings in the language of e. These states distinguish between different contexts in which a symbol appears, so they can be used to find the context corresponding to the first symbol of a handle. – LaLonde was the first to elaborate the idea of recognizing handles in the way just outlined [28,29]. LaLonde mentions that his parse tables can be divided into essentially two classes (readahead and readback), but this is not so evident from the way he describes the parsing algorithm. – Chapman [26,27] gives a simpler construction for the readback automata, derived from a particular algorithm for computing LALR(1) lookahead sets. The construction may yield readback automata that are non-deterministic. Chapman restricts his method to grammars for which this is not the case. Chapman clearly distinguishes readahead and readback automata and describes the parsing algorithm as a piece of program in which the forward and backward phases can easily be recognized. – Madsen and Christensen [25] base their method on ECFGs rather than RRPGs. They present an LR(0) construction based on sets of items which are rules of the ECFG with markers. In order to determine the left end of the handle they use a recursive algorithm which matches the actual handle with the possible forms of the production right part subexpressions. In order to give an impression of the way a parser with readback automata works, we present below a somewhat polished version of Chapman’s algorithm in [27]. The components have the following meanings: Q normal parser states, q0 initial state, δ : Q × T → Q forward transitions, R readback states, F ⊆ R accepting readback states, ρ : R × Q → R readback transitions, I : Q × P → R initial readback states.

416

K. Hemerik

con G = (N, T, P, S) : RRP G; { G is the given grammar} con LRB = (Q, N ∪ T, P, q0 , δ, R, ρ, I, F ); {LRB is LR(1) automaton with readback for G} var in : T ∗ ; {input sequence} sym : T ; {lookahead symbol} q : Q; {current state} σ : stack of Q; {parse stack} in := IN P U T ⊕ ; q := q0 ; σ := q; nextsym; do δ(q, sym) :: shif t(s) → q := s; σ.push(q); nextsym [] δ(q, sym) :: r educe(A → α) → |[ var r : R; r := I(q, A → α); {initial readback state} do r  F → r := ρ(r, σ.t op); {readback loop} σ.pop od ; let s  Q s.t. δ(σ.top, A) :: shif t(s); q := s; σ.push(q) ]| od ; if δ(q, sym) :: accept → skip [] δ(q, sym) :: error → errormessage(σ, sym) fi 5.3

Purdom and Brown’s Technique

Purdom and Brown [32] start out with an RRPG where each right part is a DFA. To this grammar they apply a construction which is very similar to the standard LALR(k)-construction for CFGs. The main difference with the approaches in the previous subsection is in the handling of the stack. A state is stacked only when the symbol being processed indicates the beginning of a new right side. When the end of the production is found, exactly one entry is popped from the stack. This approach does not work for every ELR(k) grammar because for some (state, symbol) pairs it may not be possible to tell whether the parser is starting a new right side without seeing more of the input. In this situation the construction produces a parser with a stacking conflict.

Towards a Taxonomy for ECFG and RRPG Parsing

417

Purdom and Brown also present an algorithm for transforming any ELR(k) grammar whose grammar has stacking conflicts into one whose parser has none. They claim that this transformation permits to parse any ELR(k) grammar with their method. Several variations on the basic scheme by Purdom and Brown have been published, which differ mainly in the way stacking conflicts are handled: – Nakata and Sassa [31] use lookback states at reduction if stacking conflicts occur; – Shin and Choe [34] improve on the storage requirements of Nakata and Sassa [31] by using only kernel items in the construction and by allowing NFAs rather than DFAs in the right parts of productions; – Fortes G´ alvez [38] points out some errors in [31,34] by means of a counterexample. – Sassa and Nakata [33] use counters at reduction if stacking conflicts occur. – Zhang and Nakata [35] use path numbers at reduction if stacking conflicts occur; – Morimoto and Sassa [30] additionally put production symbols on the stack during shift actions in order to reduce the work needed during reduce actions. 5.4

Embedding in Different LR-Like Frameworks

– Colby and Bermudez [36] generalize the counters of Sassa and Nakata [33] and embed the resulting parser in a general theory of LR-like parsers developed by Bermudez. – Kannapinn’s dissertation [37] consists of two parts. In the first part he studies how redundancy may be eliminated from LR parsers. In the second part he uses his framework to design an LR-parser for ECFGs. He first gives a very critical review of many existing publications on the same subject and then presents his own constructions, which are essentially as follows: right parts of ECFGs are mapped to equivalent FAs; these in turn are mapped to equivalent right-linear subgrammars. This way, the construction of ELRparsers for ECFGs and for RRPGs can be unified and both can be reduced to the construction of LR-parsers for pure CFGs. It is a pity that this thorough and critical work, published in German, has not received a wider readership.

6

Tabular Parsers

Classical tabular parsers like Earley’s method [39] can handle arbitrary CFGs, even ambiguous ones. Usually, they are presented in the form of a subject string w  T ∗ and a matrix M , where Mij contains a set of elements related to all derivations of substring wij . The matrix is filled by a kind of dynamic programming algorithm, and eventually M0n holds information about all derivations of w.

418

K. Hemerik

Not much literature can be found on extending tabular methods to ECFGs: – Leermakers [40] presents a formalism for Earley-like parsers, which accomodates the simulation of non-deterministic pushdown automata. In particular, the theory is applied to non-deterministic LR-parsers for Recursive Transition Networks, which are equivalent to RRPGs. – Schneider [41] shows how ECFGs can be embedded in a more general formalism called state transition grammars (STG), and presents an Earley-like parser schema for STGs. – Spanbroek [42] gives full formal derivations of ECFG versions of the CockeYounger-Kasami algorithm and the bottom-up Earley algorithm.

7

Concluding Remarks

The picture of parsing ECFGs and RRPGs emerging from the survey above is: – Recursive descent parsing is so simple to use that not many feel tempted to publish about its theory; – What has been published about LR-like parsing theory is so complex that not many feel tempted to use it; – LL-like parsing seems to have little theoretical or practical relevance; – Tabular parsing seems feasible, but is largely unexplored. Of course, such a simplistic resum´e does not do justice to the great efforts that have gone into research and implementation of the methods described. But it is a striking phenomenon that the ideas behind recursive descent parsing of ECFGs can be grasped and applied immediately, whereas most of the literature on LR-like parsing of RRPGs is very difficult to access. Given the developments in computing power and software engineering, and the practical importance of ECFGs and RRPGs, a uniform and coherent treatment of the subject seems in order. We hope that this paper is a useful step towards that goal. Acknowledgments. Mark van den Brand, Loek Cleophas and an anonymous referee gave many useful comments on an earlier version of this paper. Due to space limitations they could not all be taken into account.

References 1. Wirth, N.: What can we do about the unnecessary diversity of notation for syntactic definitions? CACM 20, 822–823 (1977) 2. ISO/IEC: International Standard EBNF Syntax Notation. 14977 edn. (1996), http://www.iso.ch/cate/d26153.html 3. Conway, M.E.: Design of a separable transition-diagram compiler. CACM 6, 396– 408 (1963) 4. Lomet, D.B.: A formalization of transition diagram systems. JACM 20, 235–257 (1973)

Towards a Taxonomy for ECFG and RRPG Parsing

419

5. Perlin, M.: LR recursive transition networks for Earley and Tomita parsing. In: Procs. 29th Annual Meeting on Association for Computational Linguistics (ACL), Berkeley, California, pp. 98–105 (1991) 6. Woods, W.A.: Transition network grammars for natural language analysis. CACM 13, 591–606 (1970) 7. Broy, M.: Program construction by transformations: a family tree of sorting programs. In: Biermann, A.W., Guiho, G. (eds.) Computer Program Synthesis Methodologies, pp. 1–49. Reidel (1983) 8. Darlington, J.: A synthesis of several sorting algorithms. Acta Inf. 11, 1–30 (1978) 9. Jonkers, H.: Abstraction, specification and implementation techniques, with an application to garbage collection. PhD thesis, Technische Univ. Eindhoven (1983) 10. Watson, B.W.: Taxonomies and Toolkits of Regular Language Algorithms. PhD thesis, Technische Universiteit Eindhoven (1995) 11. Watson, B.W.: Implementing and using finite automata toolkits. In: Kornai, A. (ed.) Procs. 12th European Conference on Artificial Intelligence, Budapest, Hungary, pp. 97–100 (1996) 12. Cleophas, L.: Tree Algorithms - Two Taxonomies and a Toolkit. PhD thesis, Technische Universiteit Eindhoven (2008) 13. Cleophas, L.: Forest FIRE and FIRE Wood - tools for tree automata and tree algorithms. In: FSMNLP (2008) 14. Wilhelm, R., Maurer, D.: Compiler Design. Addison-Wesley, Reading (1995) 15. Lewi, J., de Vlaminck, K., Steegmans, E., Horebeek, I.V.: Software Development by LL(1) Syntax Description. Wiley, Chichester (1992) 16. Heilbrunner, S.: On the definition of ELR(k) and ELL(k) grammars. Acta Informatica 11, 169–176 (1979) 17. Lucas, P.: The structure of formula-translators. ALGOL Bulletin 16 (1961) 18. Wirth, N.: Algorithms + Data Structures = Programs. Prentice-Hall, Englewood Cliffs (1975) 19. Lewi, J., Vlaminck, K.D., Huens, J., Huybrechts, M.: The ELL(l) parser generator and the error recovery mechanism. Acta Informatica 10, 209–228 (1978) 20. Keim, E.: Theory and implementation of a family of parser components. Master’s thesis, Dept. of Math. and Comp.Sci., Technische Universiteit Eindhoven (2007) 21. Ssanyu, J., Hemerik, K.: Algorithms for recursive descent parsing of ECFGs. (in preparation, 2008) 22. Br¨ uggemann-Klein, A., Wood, D.: On predictive parsing and extended contextfree grammars. In: Champarnaud, J.-M., Maurel, D. (eds.) CIAA 2002. LNCS, vol. 2608, pp. 239–247. Springer, Heidelberg (2003) 23. Br¨ uggemann-Klein, A., Wood, D.: The parsing of extended context-free grammars. HKUST Theoretical Computer Science Center Research Report HKUST-TCSC2002-08, Hong Kong University (2002) 24. Celentano, A.: An LR parsing technique for extended context-free grammars. Computer Languages 6, 95–107 (1981) 25. Madsen, O.L., Kristensen, B.B.: LR-parsing of extended context free grammars. Acta Informatica 7, 61–73 (1976) 26. Chapman, N.P.: LALR(1,1) parser generation for regular right part grammars. Acta Informatica 21, 29–45 (1984) 27. Chapman, N.P.: LR Parsing - Theory and Practice. Cambridge Univ. Press, Cambridge (1987) 28. LaLonde, W.R.: Regular right part grammars and their parsers. CACM 20, 731– 741 (1977)

420

K. Hemerik

29. LaLonde, W.R.: Lalonde: Constructing LR parsers for regular right part grammars. Acta Informatica 11, 177–193 (1979) 30. Morimito, S.I., Sassa, M.: Yet another generation of LALR parsers for regular right part grammars. Acta Informatica 37, 671–697 (2001) 31. Nakata, I., Sassa, M.: Generation of efficient LALR parsers for regular right part grammars. Acta Informatica 23, 149–162 (1986) 32. Purdom, P.W., Brown, C.A.: Parsing extended LR(k) grammars. Acta Informatica 15, 115–127 (1981) 33. Sassa, M., Nakata, I.: A simple realization of LR-parsers for regular right part grammars. Information Processing Letters 24, 113–120 (1987) 34. Shin, H.C., Choe, K.M.: An improved LALR(k) parser generation for regular right part grammars. Inf. Proc. Lett. 47, 123–129 (1993) 35. Zhang, Y., Nakata, I.: Generation of path directed LALR(k) parsers for regular right part grammars. J. Inf. Process. 14, 325–334 (1991) 36. Colby, J.E., Bermudez, M.E.: Lookahead LR parsing with regular right part grammars. Intern. J. Computer Math. 64, 1–15 (1997) 37. Kannapinn, S.: Eine Rekonstruktion der LR-Theorie zur Elimination von Redundanz mit Anwendung auf den Bau von ELR-Parsern. PhD thesis, Technische Universit¨ at Berlin (2001) (in German) 38. Fortes G´ alvez, J.: A note on a proposed LALR parser for extended context-free grammars. Inf. Proc. Lett. 50, 303–305 (1994) 39. Earley, J.C.: An efficient context-free parsing algorithm. CACM 13, 94–102 (1970) 40. Leermakers, R.: How to cover a grammar. In: Procs. 27th Ann. Meeting of Association for Computational Linguistics, Vancouver, Canada, pp. 135–142 (1989) 41. Schneider, K.M.: Parsing schemata for grammars with variable number and order of constituents. In: Procs. 18th Conf. on Comp. Linguistics, vol. 2, pp. 733–739 (2000) 42. Spanbroek, M.: Towards a unification of regular and context-free recognition. Master’s thesis, Dept. of Math. and Comp. Sci., Technische Universiteit Eindhoven (2005)

A

Interpreting Limited Backtrack Recursive Descent Parser Scheme

As an example of the way the parsing algorithms are described in the taxonomy, we show the abstract code for one of the algorithms. The parser is a limited backtrack recursive descent parser which interprets the grammar and which makes use of a scanner sc and a tree builder tb. The parser is coded as a recursive procedure T (↓ e, ↑ r, ↑ t), where input parameter e is a regular expression over terminals and nonterminals; boolean output parameter r indicates whether the parse was successful. If so, output parameter t holds the constructed tree. The characteristics of the algorithm and the corresponding code are given below: grammar kind grammar conditions grammar processing architecture strategy scanner operations tree builder actions

ECFG no left recursion, no Nullable(e) for expressions of the form e∗ interpreted recursive descent procedure with scanner sc and tree builder tb limited backtrack, no lookahead, success boolean, no memo sym, nextsym, mark, reset mkeps, mkterm, mkprod, mkdot, mkstick, mkstar

Towards a Taxonomy for ECFG and RRPG Parsing proc T (↓ e : SE; ↑ r : bool; ↑ t : Tree) = if e :: φ → r, t := false, nil [] e :: ε → r, t := true, tb.mkeps(˜ e) [] e :: term(a) → if sc.sym = a → sc.nextsym; r, t := true, tb.mkterm(˜ e, a) [] sc.sym = a → r, t := false, nil fi [] e :: nonterm(A) → |[ var b : bool; t : Tree  T (↓ P (A); ↑ b; ↑ t ); if b → t := tb.mkprod(˜ e, A, t ) [] ¬b → t := nil fi ; r := b ]| [] e :: (e0 · . . . ·el−1 ) → |[ var j : nat; b : bool; t : Tree; s : seq of Tree  j, b, s := 0, true, ; do (j = l) ∧ b → T (↓ ej ; ↑ b; ↑ t ); s := s ⊕ t  j := j + 1 od ; if b → t := tb.mkdot(˜ e, s) [] ¬b → t := nil fi ; r := b; ]| [] e :: (e0 | . . . | el−1 ) → |[ var m, j : nat; b : bool; t : Tree  m := sc.mark; j, b, t := 0, false, nil; do (j = l) ∧ ¬b → T (↓ ej ; ↑ b; ↑ t ); if b → t := tb.mkstick(˜ e, j, t ) [] ¬b → sc.reset(m) fi ; j := j + 1 od ; r := b; ]| [] e :: f ∗ → |[ var m : nat; b : bool; t : Tree; s : seq of Tree  b, s := true, ; do b → m := sc.mark; T (↓ f ; ↑ b; ↑ t ); if b → s := s ⊕ t  [] ¬b → sc.reset(m) fi ; od ; r, t := true, tb.mkstar(˜ e, s) ]| fi

421

Counting Parameterized Border Arrays for a Binary Alphabet Tomohiro I1 , Shunsuke Inenaga2 , Hideo Bannai1 , and Masayuki Takeda1 1

2

Department of Informatics, Kyushu University Graduate School of Information Science and Electrical Engineering, Kyushu University 744 Motooka, Nishiku, Fukuoka, 819–0395 Japan {tomohiro.i,bannai,takeda}@i.kyushu-u.ac.jp, [email protected]

Abstract. The parameterized pattern matching problem is a kind of pattern matching problem, where a pattern is considered to occur in a text when there exists a renaming bijection on the alphabet with which the pattern can be transformed into a substring of the text. A parameterized border array (p-border array) is an analogue of a border array of a standard string, which is also known as the failure function of the Morris-Pratt pattern matching algorithm. In this paper we present a linear time algorithm to verify if a given integer array is a valid p-border array for a binary alphabet. We also show a linear time algorithm to compute all binary parameterized strings sharing a given p-border array. In addition, we give an algorithm which computes all p-border arrays of length at most n, where n is a a given threshold. This algorithm runs in time linear in the number of output p-border arrays.

1 1.1

Introduction Parameterized Matching and Parameterized Border Array

The parameterized matching (p-matching) problem [1] is a kind of string matching problem, where a pattern is considered to occur in a text when there exists a renaming bijection on the alphabet with which the pattern can be transformed into a substring of the text. A parameterized string (p-string) is formally an element of (Π ∪ Σ)∗ , where Π is the set of parameter symbols and Σ the set of constant symbols. The renaming bijections used in p-matching are the identity on Σ, that is, every constant symbol X ∈ Σ is mapped to X, while symbols in Π can be interchanged. Parameterized matching has applications in software maintenance [2,1], plagiarism detection [3], and RNA structural matching [4], thus it has been extensively studied in the last decade [5,6,7,8,9,10,11,12]. Of various efficient methods solving the p-matching problem, this paper focuses on the algorithm of Idury and Sch¨affer [13] that solves the p-matching problem for multiple patterns. Their algorithm modifies the Aho-Corasick automata [14], replacing the goto and fail functions with the pgoto and pfail functions, respectively. When the input is a single pattern p-string of length m, the A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 422–433, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Counting Parameterized Border Arrays for a Binary Alphabet

423

pfail function can be implemented by an array of length m, and we call the array the parameterized border array (p-border array) of the pattern p-string, which is the parameterized version of the border array [15]. The p-border array of a given pattern can be computed in linear time [13]. 1.2

Reverse and Enumerating Problems on Strings

The reverse problem for standard border arrays [15] was first introduced by Franˇek et al. [16]. They proposed a linear time algorithm to verify if a given integer array is the border array of some string. Their algorithm works for both bounded and unbounded alphabets. Duval et al. [17] proposed a simpler algorithm to solve the same problem in linear time for bounded alphabets. Moore et al. [18] presented an algorithm to enumerate all border arrays of length at most n, where n is a given positive integer. They proposed a notion of b-equivalence of strings such that two strings are b-equivalent if they have the same border array. The lexicographically smallest one of each b-equivalence class is called b-canonical string of the class. Their algorithm is also able to output all b-canonical strings of length up to a given integer n. Franˇek et al. [16] pointed out that the time complexity analysis of [18] is incorrect, and showed a new algorithm which solves the same problem in O(bn ) time using O(bn ) space, where bn denotes the number of border arrays of length at most n. The reverse problem for some other string data structures, such as suffix arrays [19], directed acyclic word graphs [20], directed acyclic subsequence graphs [21] have been solved in linear time [22,23]. The problem of enumerating all suffix arrays was considered in [24]. An algorithm to enumerate all p-distinct strings was proposed in [18], where two strings are said to be p-distinct if they do not parameterized-match. 1.3

Our Contribution

This paper considers the reversal of the problem of computing the p-border array of a given pattern p-string. That is, given an integer array α, determine if there exists a p-string whose p-border array is α. In this paper, we present a linear time algorithm which solves the above problem for a binary parameter alphabet (|Π| = 2). We then consider a more challenging problem: given a positive integer n, enumerate all p-border arrays of length at most n. We propose an algorithm that solves the enumerating problem in O(Bn ) time for a binary parameter alphabet, where Bn is the number of all p-border arrays of length n for a binary parameter alphabet. We also give a simple algorithm to output all strings which share the same p-border array. A p-border is a dual concept of a parameterized period of a p-string. Apostolico and Giancarlo [11] showed that a complete analogy to the weak periodicity lemma [25] stands for p-strings over a binary alphabet. Our result reveals yet another similarity of p-strings over a binary alphabet and standard strings in terms of periodicity.

424

2 2.1

T. I et al.

Preliminaries Parameterized String Matching

Let Σ and Π be two disjoint finite sets of constant symbols and parameter symbols, respectively. An element of (Σ ∪ Π)∗ is called a p-string. The length of any p-string s is the total number of constant and parameter symbols in s and is denoted by |s|. For any p-string s of length n, the i-th symbol is denoted by s[i] for each 1 ≤ i ≤ n, and the substring starting at position i and ending at position j is denoted by s[i : j] for 1 ≤ i ≤ j ≤ n. In particular, s[1 : j] and s[i : n] denote the prefix of length j and the suffix of length n − i + 1 of s, respectively. Any two p-strings s and t of the same length m are said to parameterized match if s can be transformed into t by applying a renaming function f from the symbols of s to the symbols of t, such that f is the identity on the constant alphabet. For example, let Π = {a, b, c}, Σ = {X, Y}, s = abcXabY and t = bcaXbcY. We then have s  t with the renaming function f such that f (a) = b, f (b) = c, f (c) = a, f (X) = X, and f (Y) = Y. We write s  t when s and t p-match. Amir et al. [5] showed that we have only to consider p-strings over Π when considering p-matching. Lemma 1 ([5]). The p-matching problem on alphabet Σ ∪ Π is reducible in linear time to the p-matching problem on alphabet Π. 2.2

Parameterized Border Arrays

As in the case of standard string matching, we can define the parameterized border (p-border) and the parameterized border array (p-border array). Definition 1. A parameterized border ( p-border) of a p-string s of length n is any integer j such that 0 ≤ j < n and s[1 : j]  s[n − j + 1 : n]. For example, the set of p-borders of p-string aabbaa is {4, 2, 1, 0}, since aabb  bbaa, aa  aa, a  a, and ε  ε. Definition 2. The parameterized border array ( p-border array) βs of any pstring s of length n is an array of length n such that βs [i] = j, where j is the longest p-border of s[1 : i]. For example, the p-border array of p-string aabbaa is [0, 1, 1, 2, 3, 4]. When it is clear from the context, we abbreviate βs as β. The p-border array βs of p-string s was first explicitly introduced by Idury and Sch¨ affer [13] as the pfail function, where the pfail function is used in their AhoCorasick [14] type algorithm that solves the p-matching problem for multiple patterns. Given a pattern p-string p of length m, the p-border array βp can be computed in O(m log |Π|) time, and the p-matching problem can be solved in O(n log |Π|) time for any text p-string of length n.

Counting Parameterized Border Arrays for a Binary Alphabet

2.3

425

Problems

This paper deals with the following problems. Problem 1 (Verifying valid p-border array). Given an integer array α of length n, determine if there exists a p-string s such that βs = α. Problem 2 (Computing all p-strings sharing the same p-border array). Given an integer array α which is a valid p-border array, compute every p-string s such that βs = α. Problem 3 (Computing all p-border arrays). Given a positive integer n, compute all p-border arrays of length at most n. In the following section, we give efficient solutions to the above problems for a binary alphabet, that is, |Π| = 2.

3

Algorithms

This section presents our algorithms which solve Problem 1, Problem 2 and Problem 3 for the case |Π| = 2. We begin with the basic proposition on p-border arrays. Proposition 1. For any p-border array β[1..i] of length i ≥ 2, β[1..i − 1] is a p-border array of length i − 1. Proof. Let s be any p-string such that βs = β. It is clear from Definition 2 that βs [1..i − 1] is the p-border array of the p-string s[1 : i − 1].   Due to the above proposition, given an integer array α[1..n], we can check if it is a p-border array of some string of length n by testing each element of α in increasing order (from 1 to n). If we find any 1 ≤ i ≤ n such that α[1..i] is not a p-border array of length i, then α[1..n] can never be a p-border of length n. In what follows, we show how to check each element of a given integer array in increasing order. For any p-border array β of length n and any integer 1 ≤ i ≤ n, let  β[i] if k = 1, k β [i] = k−1 β[β [i]] if k > 1 and β k−1 [i] ≥ 1. It follows from Definition 2 that the sequence i, β[i], β 2 [i], . . . is monotone decreasing to zero, hence finite. Lemma 2. For any p-string s of length i, {βs1 [i], βs2 [i], . . . , 0} is the set of the p-borders of s. Proof. First we show by induction that for every k, 1 ≤ k ≤ k  , βsk [i] is a p border of s, where k  is the integer such that βsk [i] = 0. By Definition 2, βs1 [i] is the longest p-border of s. Suppose that for some k, 1 ≤ k < k  , βsk [i] is a

426

T. I et al.

p-border of s. Here βsk+1 [i] is the longest p-border of βsk [i]. Let f and g be the bijections such that f (s[1])f (s[2]) · · · f (s[βsk [i]]) = s[i − βsk [i] + 1 : i],

g(s[1])g(s[2]) · · · g(s[βsk+1 [i]]) = s[βsk [i] − βsk+1 [i] + 1 : βsk [i]]. Since f (g(s[1]))f (g(s[2])) · · · f (g(s[βsk+1 [i]])) = f (s[βsk [i] − βsk+1 [i] + 1])f (s[βsk [i] − βsk+1 [i] + 2]) · · · f (s[βsk [i]]) = s[i − βsk+1 [i] + 1 : i],

we obtain s[1 : βsk+1 [i]]  s[i − βsk+1 [i] + 1 : i]. Hence βsk+1 [i] is a p-border of s. We now show any other j is not a p-border of s. Assume for contrary that j, βsk+1 [i] < j < βsk [i], is a p-border of s. Let q be the bijection such that q(s[i − j + 1])q(s[i − j + 2]) · · · q(s[i]) = s[1 : j]. Since q(f (s[βsk [i] − j + 1]))q(f (s[βsk [i] − j + 2])) · · · q(f (s[βsk [i]])) = q(s[i − j + 1])q(s[i − j + 2]) · · · q(s[i]) = s[1 : j], we obtain s[1 : j]  s[βsk [i] − j + 1 : βsk [i]]. Hence j is a p-border of s[1 : βsk [i]]. However this contradicts with the definition that βsk+1 [i] is the longest p-border   of s[1 : βsk [i]]. Lemma 3. For any p-string s of length i ≥ 1 and a ∈ Π, every p-border of sa is an element of the set {βs1 [i] + 1, βs2 [i] + 1, . . . , 1}. Proof. Assume for contrary that sa has a p-border j + 1 ∈ / {βs1 [i] + 1, βs2 [i] + 1, . . . , 1}. Since s[1 : j + 1]  s[i − j + 1 : i]a, we have s[1 : j]  s[i − j + 1 : i] and j is a p-border of s. It follows from Lemma 2 that j ∈ {βs1 [i], βs2 [i], . . . , 0}. This contradicts with the assumption.   Based on Lemma 2 and Lemma 3, we can efficiently compute the p-border array βs of a given p-string s. Also, our algorithm to solve Problem 1 is based on these lemmas. Note that Proposition 1, Lemma 2 and Lemma 3 hold for p-strings over Π of arbitrary size. In the sequel we show how to select m ∈ {βs1 [i] + 1, βs2 [i] + 1, . . . , 1} such that βs [1..i]m is a valid p-border array of length i + 1. The following proposition, lemmas and theorems hold for a binary parameter alphabet, |Π| = 2. For p-border arrays of length at most 2, we have the next proposition. Proposition 2. For any p-string s of length 1, βs [1] = 0. For any p-string s of length 2, βs [2] = 1.

Counting Parameterized Border Arrays for a Binary Alphabet i

s

427

a

f βh-1[i]+1 g

f

βh [i]+1

Fig. 1. Illustration for Lemma 5

Proof. Let Π = {a, b}. It is clear that the longest p-border of a and b is 0. The p-strings of length 2 over Π are aa, ab, ba, and bb. Obviously the longest p-border of each of them is 1.   For p-border arrays of length more than 2, we have the following lemmas. Lemma 4. For any p-string s ∈ Π ∗ , if j ≥ 2 is a p-border of sa with a ∈ Π, then j is not a p-border of sb, where b ∈ Π − {a}. Proof. Assume for contrary that j is a p-border of sb. Then, let f and g be the bijections on Π such that f (s[1])f (s[2]) · · · f (s[j]) = s[i − j + 2 : i]a, g(s[1])g(s[2]) · · · g(s[j]) = s[i − j + 2 : i]b. We get from f (s[1])f (s[2]) · · · f (s[j−1]) = s[i−j+2 : i] = g(s[1])f (s[2]) · · · g(s[j− 1]) that f and g are the same bijections. However, f (s[j]) = a = b = g(s[j]) implies that f and g are different bijections, a contradiction. Hence j is not a p-border of sb.   Lemma 5. For any p-string s of length i, if βs [βsh−1 [i] + 1] = βsh [i] + 1 and βsh−1 [i] + 1 is a p-border of sa with a ∈ Π, then βsh [i] + 1 is a p-border of sa. (See also Fig. 1.) Proof. Let f and g be the bijections on Π such that f (s[1])f (s[2]) · · · f (s[βsh−1 [i] + 1]) = s[i − βsh−1 [i] + 1 : i]a, g(s[1])g(s[2]) · · · g(s[βsh [i] + 1]) = s[βsh−1 [i] − βsh [i] + 1 : βsh−1 [i] + 1]. Since f (g(s[1]))f (g(s[2])) · · · f (g(s[βsh [i] + 1])) = f (s[βsh−1 [i] − βsh [i] + 1])f (s[βsh−1 [i] − βsh [i] + 2]) · · · f (s[βsh−1 [i] + 1]) = s[i − βsh [i] + 1 : i]a,

we obtain s[1 : βsh [i] + 1]  s[i − βsh [i] + 1 : i]a. Hence βsh [i] + 1 is a p-border of sa.  

428

T. I et al. i

s

a

f βh-1[i]+1 q βh [i]

f

q

f

q

f

a b

Fig. 2. Illustration for Lemma 6

Lemma 6. For any p-string s of length i, if βs [βsh−1 [i] + 1] = βsh [i] + 1 and βsh−1 [i] + 1 is a p-border of sa with a ∈ Π, then βsh [i] + 1 is a p-border of sb such that b ∈ Π − {a}. (See also Fig. 2.) Proof. Let f and g be the bijections on Π such that f (s[1])f (s[2]) · · · f (s[βsh−1 [i] + 1]) = s[i − βsh−1 [i] + 1 : i]a, q(s[1])q(s[2]) · · · q(s[βsh [i]]) = s[βsh−1 [i] − βsh [i] + 1 : βsh−1 [i]]. Because βs [βsh−1 [i] + 1] = βsh [i] + 1, we know that q(s[βsh [i] + 1]) = s[βsh−1 [i] + 1]. Since f (s[βsh−1 [i] + 1]) = a and Π = {a, b}, f (q(s[βsh [i] + 1])) = b. Hence βsh [i] + 1 is a p-border of sb.   The following is a key lemma to solving our problems. Lemma 7. For any p-border array β of length i ≥ 2, β[1..i]m1 and β[1..i]m2 are the p-border arrays of length i + 1, where m1 = β[i] + 1 and ⎧ l−1 l  ⎪ ⎨β l [i] + 1 if β[β [i] + 1] = β [i] + 1 for some 1 < l < k and m2 = β[β h−1 [i] + 1] = β h [i] + 1 for any 1 < h < l, ⎪ ⎩ 1 otherwise, 

where k  is the integer such that β k [i] = 0. Proof. Consider any p-string s of length i such that βs = β. By definition, there exists a bijection f on Π such that f (s[1])f (s[2]) · · · f (s[β[i]]) = s[i − β[i] + 1 : i]. Let a = f (s[β[i]+1]). Then f (s[1])f (s[2]) · · · f (s[β[i]])f (s[β[i]+1]) = s[i−β[i]+1 : i]a. Note that β[1..i](β[i] + 1) is the p-border array of sa because sa can have no p-borders longer than β[i] + 1. It follows from Lemma 5 that β h [i] + 1 is a p-border of sa. Then, by Lemma 6, l β [i] + 1 is a p-border of sb. Since β h [i] ≥ 1, by Lemma 4, β h [i] + 1 is not a pborder of sb. Hence β l [i] + 1 is the longest p-border of sb.  

Counting Parameterized Border Arrays for a Binary Alphabet

429

Algorithm 1. Algorithm to solve Problem 1

1 2 3 4 5 6 7 8 9 10 11

Input: α[1..n] : a given integer array Output: return whether α is a valid p-border array or not if α[1..2] = [0, 1] then return invalid; for i = 3 to n do if α[i] = α[i − 1] + 1 then continue; d ← α[i − 1]; d ← α[d ]; while d > 0 & d + 1 = α[d + 1] do d ← d; d ← α[d ]; if α[i] = d + 1 then continue; return invalid; return valid;

We are ready to state the following theorem. Theorem 1. Problem 1 can be solved in linear time for a binary parameter alphabet. Proof. Algorithm 1 describes the operations to solve Problem 1. Given an integer array of length n, the algorithm first checks if α[1..2] = [0, 1] due to Proposition 2. If α[1..2] = [0, 1], then for each i = 3, . . . , n (in increasing order) the algorithm checks whether α[i] satisfies one of the conditions of Lemma 7. The time analysis is similar to that of Theorem 2.3 of [16]. In each iteration of the for loop, the value of d increases by at most 1. However, each execution of the while loop decreases the value of d by at least 1. Hence the total time cost of the for loop is O(n).   Theorem 2. Problem 2 can be solved in linear time for a binary parameter alphabet. Proof. It follows from Proposition 2 that the p-border array of all p-string of length 2 (aa, ab, ba, and bb) is [0, 1]. By Proposition 1, for any p-border array β[1..n] with n ≥ 2, we have β[1..2] = [0, 1]. Hence each p-border array β[1..n] with n ≥ 2 corresponds to exactly four p-strings each of which begins with aa, ab, ba, and bb, respectively. Algorithm 2 is an algorithm to solve Problem 2. Technically xaa can be computed by saa [β[i]] xor saa [β[i]+1] xor saa [i] on binary alphabet Π = {0, 1}. Hence this counting algorithm works in linear time.   We now consider Problem 3. By Proposition 1 and Lemma 7, computing all p-border arrays of length at most n can be accomplished using a rooted tree structure Tn of height n − 1. Each node of Tn of height i − 1 corresponds to an integer j such that j is the longest p-border of some p-string of length i over a binary alphabet, hence the path from the root to that node represents the p-border array of the p-string. Fig. 3 represents T4 .

430

T. I et al.

Algorithm 2. Algorithm to compute all p-strings sharing the same p-border array

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Input: β[1..n] : a p-border array Output: all p-strings sharing the same p-border array β[1..n] saa ← aa; sab ← ab; sbb ← bb; sba ← ba; for i = 3 to n do Let f be the bijection on Π s.t. f (saa [β[i]]) = saa [i]; Let g be the bijection on Π s.t. g(sab [β[i]]) = sab [i]; xaa ← f (saa [β[i] + 1]); xab ← g(sab [β[i] + 1]); xaa ← y ∈ Π − {xaa }; xab ← z ∈ Π − {xab }; if β[i] = β[i − 1] + 1 then saa [i] ← xaa ; sab [i] ← xab ; sbb [i] ← xaa ; sba [i] ← xab ; else saa [i] ← xaa ; sab [i] ← xab ; sbb [i] ← xaa ; sba [i] ← xab ; end Output: saa [1 : n], sab [1 : n], sbb [1 : n], sba [1 : n]

(0) (1) (1) (1)

(2) (2)

(1)

(3)

Fig. 3. The tree T4 which represents all p-border arrays of length at most 4 for a binary alphabet

Theorem 3. Problem 3 can be solved in O(Bn ) time for a binary parameter alphabet, where Bn denotes the number of p-border arrays of length n. Proof. Proposition 2 and Lemma 7 imply that every internal node of Tn of height at least 1 has exactly two children. Hence the total number of nodes of Tn is O(Bn ). We compute Tn in a depth-first manner. Algorithm 3 shows a function that computes the children of a given node of Tn . It is not difficult to see that each child of a given node can be computed in amortized constant time. Hence   Problem 3 can be solved in O(Bn ) time for a binary parameter alphabet. We remark that if each p-border array in Tn can be discarded after it is generated, then we can compute all p-border arrays of length at most n using O(n) space. Since every internal node of Tn of height at least 1 has exactly two children

Counting Parameterized Border Arrays for a Binary Alphabet

431

Algorithm 3. Function to compute the children of a node of Tn

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Input: i : length of the current p-border array, 2 ≤ i ≤ n Result: compute the children of the current node // β[1..n] is allocated globally and β[1..i] represents the current p-border array. function getChildren(i) if i = n then return; β[i + 1] ← β[i] + 1; report β[i + 1]; getChildren(i + 1); d ← β[i]; d ← β[d ]; while d > 0 & d + 1 = β[d + 1] do d ← d; d ← β[d ]; β[i + 1] ← d + 1; report β[i + 1]; getChildren(i + 1); return;

and the root has one child, Bn = 2n−2 for n ≥ 2. Thus the space requirement can be reduced to O(log Bn ).

4

Conclusions and Open Problems

A parameterized border array (p-border array) is a useful data structure for parameterized pattern matching. In this paper, we presented a linear time algorithm which tests if a given integer array is a valid p-border array for a binary alphabet. We also gave a linear time algorithm to compute all binary p-strings that share a given p-border array. Finally, we proposed an algorithm which computes all p-border arrays of length at most n, where n is a given threshold. This algorithm works in O(Bn ) time, where Bn denotes the number of p-border arrays of length n for a binary alphabet. Problems 1,2, and 3 are open for a larger alphabet. To see one of the reasons of why, we show that Lemma 4 does not hold for a larger alphabet. Consider a p-string s = abac over Π = {a, b, c}. Observe that βs = [0, 1, 2, 2]. Although βs [4] = 2 is a p-border of abac, it is also a p-border of another p-string abab since ab  ab. Hence Lemma 4 does not hold if |Π| ≥ 3. Our future work also includes the following: – Verify if a given integer array is a parameterized suffix array [12]. – Compute all parameterized suffix arrays of length at most n. In [12], a linear time algorithm which directly constructs the parameterized suffix array for a given binary string was proposed. This algorithm might be used as a basis for solving the above problems regarding parameterized suffix arrays.

432

T. I et al.

References 1. Baker, B.S.: Parameterized pattern matching: Algorithms and applications. Journal of Computer and System Sciences 52(1), 28–42 (1996) 2. Baker, B.S.: A program for identifying duplicated code. Computing Science and Statistics 24, 49–57 (1992) 3. Fredriksson, K., Mozgovoy, M.: Efficient parameterized string matching. Information Processing Letters 100(3), 91–96 (2006) 4. Shibuya, T.: Generalization of a suffix tree for RNA structural pattern matching. Algorithmica 39(1), 1–19 (2004) 5. Amir, A., Farach, M., Muthukrishnan, S.: Alphabet dependence in parameterized matching. Information Processing Letters 49(3), 111–115 (1994) 6. Baker, B.S.: Parameterized pattern matching by Boyer-Moore-type algorithms. In: Proc. 6th annual ACM-SIAM Symposium on Discrete Algorithms (SODA 1995), pp. 541–550 (1995) 7. Kosaraju, S.R.: Faster algorithms for the construction of parameterized suffix trees. In: Proc. 36th Annual Symposium on Foundations of Computer Science (FOCS 1995), pp. 631–637 (1995) 8. Hazay, C., Lewenstein, M., Tsur, D.: Two dimensional parameterized matching. In: Apostolico, A., Crochemore, M., Park, K. (eds.) CPM 2005. LNCS, vol. 3537, pp. 266–279. Springer, Heidelberg (2005) 9. Hazay, C., Lewenstein, M., Sokol, D.: Approximate parameterized matching. ACM Transactions on Algorithms 3(3), Article No. 29 (2007) 10. Apostolico, A., Erd¨ os, P.L., Lewenstein, M.: Parameterized matching with mismatches. Journal of Discrete Algorithms 5(1), 135–140 (2007) 11. Apostolico, A., Giancarlo, R.: Periodicity and repetitions in parameterized strings. Discrete Applied Mathematics 156(9), 1389–1398 (2008) 12. Deguchi, S., Higashijima, F., Bannai, H., Inenaga, S., Takeda, M.: Parameterized suffix arrays for binary strings. In: Proc. The Prague Stringology Conference 2008 (PSC 2008), pp. 84–94 (2008) 13. Idury, R.M., Sch¨ affer, A.A.: Multiple matching of parameterized patterns. Theoretical Computer Science 154(2), 203–224 (1996) 14. Aho, A.V., Corasick, M.J.: Efficient string matching: An aid to bibliographic search. Communications of the ACM 18(6), 333–340 (1975) 15. Morris, J.H., Pratt, V.R.: A linear pattern-matching algorithm. Technical Report Report 40, University of California, Berkeley (1970) 16. Franek, F., Gao, S., Lu, W., Ryan, P.J., Smyth, W.F., Sun, Y., Yang, L.: Verifying a border array in linear time. J. Combinatorial Math. and Combinatorial Computing 42, 223–236 (2002) 17. Duval, J.P., Lecroq, T., Lefevre, A.: Border array on bounded alphabet. Journal of Automata, Languages and Combinatorics 10(1), 51–60 (2005) 18. Moore, D., Smyth, W., Miller, D.: Counting distinct strings. Algorithmica 23(1), 1–13 (1999) 19. Manber, U., Myers, G.: Suffix arrays: a new method for on-line string searches. SIAM J. Computing 22(5), 935–948 (1993) 20. Blumer, A., Blumer, J., Haussler, D., Ehrenfeucht, A., Chen, M.T., Seiferas, J.: The smallest automaton recognizing the subwords of a text. Theoretical Computer Science 40, 31–55 (1985) 21. Baeza-Yates, R.A.: Searching subsequences (note). Theoretical Computer Science 78(2), 363–376 (1991)

Counting Parameterized Border Arrays for a Binary Alphabet

433

22. Duval, J.P., Lefebvre, A.: Words over an ordered alphabet and suffix permutations. Theoretical Informatics and Applications 36, 249–259 (2002) 23. Bannai, H., Inenaga, S., Shinohara, A., Takeda, M.: Inferring strings from graphs and arrays. In: Rovan, B., Vojt´ aˇs, P. (eds.) MFCS 2003. LNCS, vol. 2747, pp. 208–217. Springer, Heidelberg (2003) 24. Sch¨ urmann, K.B., Stoye, J.: Counting suffix arrays and strings. Theoretical Computer Science 395(2-1), 220–234 (2008) 25. Lyndon, R.C., Sch¨ utzenberger, M.P.: The equation aM = bN cP in a free group. Michigan Math. J. 9(4), 289–298 (1962)

Bounded Hairpin Completion Masami Ito1 , Peter Leupold1, , and Victor Mitrana2,

2

1 Department of Mathematics, Faculty of Science Kyoto Sangyo University, Department of Mathematics Kyoto 603-8555, Japan {ito,leupold}@cc.kyoto-su.ac.jp University of Bucharest, Faculty of Mathematics and Computer Science Str. Academiei 14, 010014, Bucharest, Romania and Department of Information Systems and Computation Technical University of Valencia, Camino de Vera s/n. 46022 Valencia, Spain [email protected]

Abstract. We consider a restricted variant of the hairpin completion called bounded hairpin completion. The hairpin completion is a formal operation inspired from biochemistry. Applied to a word encoding a single stranded molecule x such that either a suffix or a prefix of x is complementary to a subword of x, hairpin completion produces a new word z, which is a prolongation of x to the right or to the left by annealing. The restriction considered here concerns the length of all prefixes and suffixes that are added to the current word by hairpin completion. They cannot be longer than a given constant. Closure properties of some classes of formal languages under the non-iterated and iterated bounded hairpin completion are investigated. We also define the inverse operation, namely bounded hairpin reduction, and consider the set of all primitive bounded hairpin roots of a regular language.

1

Introduction

This paper is a continuation of a series of works started with [4] (based on some ideas from [3]), where a new formal operation on words inspired by the DNA manipulation called hairpin completion was introduced. That initial work has been followed up by a several related papers ([11,12,13,14]), where both the hairpin completion as well as its inverse operation, namely the hairpin reduction, were further investigated. Several problems remained unsolved in these papers. This is the mathematical motivation for the work presented here. By considering a weaker variant of the hairpin completion operation, called here the bounded hairpin completion, we  

This work was done, while the author was funded as a post-doctoral fellow by the Japanese Society for the Promotion of Science under number P07810. Work supported by the Grant-in-Aid No. 19-07810 by Japan Society for the Promotion of Science.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 434–445, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Bounded Hairpin Completion

435

hope to be able to solve some of the problems in this new setting that remained unsolved in the aforementioned papers. Another motivation is a practical one, closely related to the biochemical reality that inspired the definition of this operation. It seems more practical to consider that the prefix/suffix added by the hairpin completion cannot be arbitrarily long. In a laboratory every step of a computation will have to make do with a finite amount of resources and finite time; thus the length of the added string would be bounded by both the amount of additional nucleic acids in the test tube and the time given for one step of computation. We briefly highlight some of the biological background that inspired the definition of the Watson-Crick superposition in [3]. The starting point is the structure of the DNA molecule. It consists of a double strand, each DNA single strand being composed by nucleotides which differ from each other in their bases: A (adenine), G (guanine), C (cytosine), and T (thymine). The two strands which form the DNA molecule are kept together by relatively weak hydrogen bonds between the bases: A always bonds with T and C with G. This phenomenon is usually referred to as Watson-Crick complementarity. The formation of these hydrogen bonds between complementary single DNA strands is called annealing. A third essential feature from biochemistry is the PCR (Polymerase Chain Reaction). From two complementary, annealed strands, where one is shorter than the other, it produces a complete double stranded DNA molecule as follows: enzymes called polymerases add the missing bases (if they are available in the environment) to the shorter strand called primer and thus turn it into a complete complement of the longer one called template. We now informally explain the superposition operation and how it can be related to the aforementioned biochemical concepts. Let us consider the following hypothetical biological situation: two single stranded DNA molecules x and y are given such that a suffix of x is Watson-Crick complementary to a prefix of y or a prefix of x is Watson-Crick complementary to a suffix of y, or x is Watson-Crick complementary to a subword of y. Then x and y get annealed in a DNA molecule with a double stranded part by complementary base pairing and then a complete double stranded molecule is formed by DNA polymerases. The mathematical expression of this hypothetical situation defines the superposition operation. Assume that we have an alphabet and a complementary relation on its letters. For two words x and y over this alphabet, if a suffix of x is complementary to a prefix of y or a prefix of x is complementary to a suffix of y, or x is complementary to a subword of y, then x and y bond together by complementary letter pairing and then a complete double stranded word is formed by the prolongation of x and y. Now the word obtained by the prolongation of x is considered to be the result of the superposition applied to x and y. Clearly, this is just a mathematical operation that resembles a biological reality considered here in an idealized way. On the other hand, it is known that a single stranded DNA molecule might produce a hairpin structure, a phenomenon based on the first two biological principles mentioned above. Here one part of the strand bonds to another part of the same strand. In many DNA-based algorithms, these DNA molecules often

436

M. Ito, P. Leupold, and V. Mitrana

cannot be used in the subsequent steps of the computation. Therefore it has been the subject of a series of studies to find encodings that will avoid the formation of hairpins, see e.g. [5,6,7] or [10] and subsequent work for investigations in the context of Formal Languages. On the other hand, those molecules which may form a hairpin structure have been used as the basic feature of a new computational model reported in [18], where an instance of the 3-SAT problem has been solved by a DNA-algorithm whose second phase is mainly based on the elimination of hairpin structured molecules. We now consider again a hypothetical biochemical situation: we are given one single stranded DNA molecule z such that either a prefix or a suffix of z is Watson-Crick complementary to a subword of z. Then the prefix or suffix of z and the corresponding subword of z get annealed by complementary base pairing and then z is lengthened by DNA polymerases up to a complete hairpin structure. The mathematical expression of this hypothetical situation defines the hairpin completion operation. By this formal operation one can generate a set of words, starting from a single word. This operation is considered in [4] as an abstract operation on formal languages. Some algorithmic problems regarding the hairpin completion are investigated in [11]. In [12] the inverse operation to the hairpin completion, namely the hairpin reduction, is introduced and one compares some properties of the two operations. This comparison is continued in [13], where a mildly context-sensitive class of languages is obtained as the homomorphic image of the hairpin completion of linear context-free languages. This is, to our best knowledge, the first class of mildly context-sensitive languages obtained in a way that does not involve grammars or acceptors. In the aforementioned papers, no restriction is imposed on the length of the prefix or suffix added by the hairpin completion. This fact seems rather unrealistic though this operation is a purely mathematical one and the biological reality is just a source of inspiration. On the other hand, several natural problems regarding the hairpin completion remained unsolved in the papers mentioned above. A usual step towards solving them might be to consider a bit less general setting and try to solve the problems in this new settings. Therefore, we consider here a restricted variant of the hairpin completion, called bounded hairpin completion. This variant assumes that the length of the prefix and suffix added by the hairpin completion is bounded by a constant.

2

Basic Definitions

We assume the reader to be familiar with the fundamental concepts of formal language theory and automata theory, particularly the notions of grammar and finite automaton [16] and basics from the theory of abstract families of languages [19]. An alphabet is always a finite set of letters. For a finite set A we denote by card(A) the cardinality of A. The set of all words over an alphabet V is denoted by V ∗ . The empty word is written λ; moreover, V + = V ∗ \ {λ}. Two languages

Bounded Hairpin Completion

437

are considered to be equal if they contain the same words with the possible exception of the empty word. A concept from the theory of abstract families of languages that we will refer to is that of a trio. This is is a non-empty family of languages closed under nonerasing morphisms, inverse morphisms and intersection with regular languages. A trio is full if it is closed under arbitrary morphisms. Given a word w over an alphabet V , we denote by |w| its length, while |w|a denotes the number of occurrences of the letter a in w. If w = xyz for some x, y, z ∈ V ∗ , then x, y, z are called prefix, subword, suffix, respectively, of w. For a word w, w[i..j] denotes the subword of w starting at position i and ending at position j, 1 ≤ i ≤ j ≤ |w|. If i = j, then w[i..j] is the i-th letter of w which is simply denoted by w[i]. Let Ω be a “superalphabet”, that is an infinite set such that any alphabet considered in this paper is a subset of Ω. In other words, Ω is the universe of the alphabets in this paper, i.e., all words and languages are over alphabets that are subsets of Ω. An involution over a set S is a bijective mapping σ : S −→ S such that σ = σ −1 . Any involution σ on Ω such that σ(a) = a for all a ∈ Ω is said to be a Watson-Crick involution. Despite the fact that this is nothing more than a fixed point-free involution, we prefer this terminology since the hairpin completion defined later is inspired by the DNA lengthening by polymerases, where the Watson-Crick complementarity plays an important role. Let · be a Watson-Crick involution fixed for the rest of the paper. The Watson-Crick involution is extended to a morphism from Ω to Ω ∗ in the usual way. We say that the letters a and a are complementary to each other. For an alphabet V , we set V = {a | a ∈ V }. Note that V and V can intersect and they can be, but need not be, equal. Recall that the DNA alphabet consists of four letters, VDN A = {A, C, G, T }, which are abbreviations for the four nucleotides and we may set A = T , C = G. We denote by (·)R the mapping defined by R : V ∗ −→ V ∗ , (a1 a2 . . . an )R = an . . . a2 a1 . Note that R is an involution and an anti-morphism ((xy)R = y R xR for all x, y ∈ V ∗ ). Note also that the two mappings · and ·R commute, namely, for any word x, (x)R = xR holds. The reader is referred to [4] or any of the subsequent papers [11,12,13,14] for the definition of the (unbounded) k-hairpin completion; it is essentially the same as for the bounded variant defined below, only without the bound |γ| ≤ p. Thus the prefix or suffix added by hairpin completion can be arbitrarily long. By the mathematical and biological reasons mentioned in the introductory part, in this work we are interested in a restricted variant of this operation that allows only prefixes and suffixes of a length bounded by a constant to be added. Formally, if V is an alphabet, then for any w ∈ V + we define the p-bounded k-hairpin completion of w, denoted by pHCk (w), for some k, p ≥ 1, as follows: pHC k (w) = {γ R w|w = αβαR γ, |α| = k, α, β ∈ V + , γ ∈ V ∗ , |γ| ≤ p} pHC k (w) = {wγ R |w = γαβαR , |α| = k, α, β ∈ V + , γ ∈ V ∗ , |γ| ≤ p} pHCk (w) = HC k (w) ∪ HC k (w).

438

M. Ito, P. Leupold, and V. Mitrana

This operation is schematically illustrated in Figure 1.

γR γ

γ

α α

β

R

γ

α

R

αR

β

Fig. 1. Bounded hairpin completion

The p-bounded hairpin completion of w is defined by  pHCk (w). pHC(w) = k≥1

As above, the p-bounded hairpin completion operation is naturally extended to languages by   pHCk (L) = pHCk (w) pHC(L) = pHC(w). w∈L

w∈L

The iterated version of the p-bounded hairpin completion is defined in a similar way to the unbounded case, namely: pHCk0 (w) = {w}, pHCkn+1 (w)  = pHCk (pHCkn (w)), ∗ pHCk (w) = n≥0 pHCkn (w),  pHCk∗ (L) = w∈L pHCk∗ (w),

3

pHC 0 (w) = {w}, pHC n+1 (w)  = pHC(pHC n (w)), ∗ pHC (w) = n≥0 pHC n (w),  pHC ∗ (L) = w∈L pHC ∗ (w).

The Non-iterated Case

The case of bounded hairpin completion is rather different in comparison to the unbounded variant considered in [11,12,13,14]. As it was expected, the closure problem of any trio under bounded hairpin completion is simple: every (full) trio is closed under this operation. Proposition 1. Every (full) trio is closed under p-bounded k-hairpin completion for any k, p ≥ 1. Proof. It is sufficient to consider a generalized sequential machine (gsm) that adds a suffix (prefix) of length at most p to its input provided that its prefix (suffix) satisfies the conditions from the definitions. As every trio is closed under gsm mappings, see [19], we are done. 2 We recall that neither the class of regular languages nor that of context-free languages is closed under unbounded hairpin completion. By the previous theorem, both classes are closed under bounded hairpin completion. On the other hand, in [11] it was proved that if the membership problem for a given language L is decidable in O(f (n)), then the membership problem for the hairpin completion of L is decidable in O(nf (n)) for any k ≥ 1. Further,

Bounded Hairpin Completion

439

the factor n is not needed for the class of regular languages, but the problem of whether or not this factor is needed for other classes remained open in [11]. An easy adaption of the algorithm provided there shows that this factor is never needed in the case of bounded hairpin completion and thus membership is always decidable in O(f (n)); presenting the adapted algorithm would exceed the scope of this work, though.

4

The Iterated Case

As in non-iterated case, the iterated bounded hairpin completion offers also a rather different picture of closure properties in comparison to the unbounded variant considered in the same papers cited above. We start with a general result. Theorem 1. Let p, k ≥ 1 and F be a (full) trio closed under substitution. Then F is closed under iterated p-bounded k-hairpin completion if and only if pHCk∗ (w) ∈ F for any word w. Proof. The “only if” part is obvious as any trio contains all singleton languages. For the “if” part, let L ∈ F be a language over the alphabet V . We write L = L1 ∪ L2 , where L1 = {x ∈ L | |x| < 2(k + p) + 1}, L2 = {x ∈ L | |x| ≥ 2(k + p) + 1}. Clearly, pHCk∗ (L) = pHCk∗ (L1 ) ∪ pHCk∗ (L2 ). As any trio contains all finite languages, it follows that any trio closed under substitution is closed under union. Therefore, as L1 is a finite language, we conclude that pHCk∗ (L1 ) ∈ F. Consequently, it remains to show that pHCk∗ (L2 ) ∈ F. Let α, β ∈ V + be two arbitrary words with |α| = |β| = k + p. We define L2 (α, β) = L2 ∩ {α}V + {β}. We have that   L2 (α, β) and pHCk∗ (L2 ) = pHCk∗ (L2 (α, β)). L2 = |α|=|β|=k+p

|α|=|β|=k+p

On the other hand, it is plain that pHCk∗ (L2 (α, β)) = s(pHCk∗ (αXβ)), where ∗ X is a new symbol not in V and s is a substitution s : (V ∪ {X})∗ −→ 2V defined by s(a) = {a} for all a ∈ V and s(X) = {w ∈ V + | αwβ ∈ L2 (α, β)}. The language {w ∈ V + | αwβ ∈ L2 (α, β)} is in F (even F is not full) as it is the image of a language from F , namely L2 (α, β), through a gsm mapping that deletes both the prefix and suffix of length k + p of the input word. By the closure properties of F , it follows that pHCk∗ (L2 (α, β)) is in F for any α, β as above, which completes the proof. 2 We recall that none of the families of regular, linear context-free, and contextfree languages is closed under iterated unbounded hairpin completion. Here the bounded hairpin completion is much more tractable.

440

M. Ito, P. Leupold, and V. Mitrana

Corollary 1. The family of context-free languages is closed under iterated pbounded k-hairpin completion for any k, p ≥ 1. Proof. By the previous result, it suffices to prove that pHCk (w) is context-free for any word w. Given w ∈ V + , we construct the arbitrary grammar G = ({S, X}, V ∪ {#}, S, P ), where the set of productions P contains the following rules: P = {S → yXz | w = zy} ∪ {z R yXz → z R yXyR z | 1 ≤ |y| ≤ p, |z| = k} ∪ {z R Xyz → z R y R Xyz | 1 ≤ |y| ≤ p, |z| = k} ∪ {X → #}. By a result of Baker (see [1]), the language generated by G is context-free. Further we have that pHCk∗ (w) = h(cp(L(G)) ∩ V + {#}). Here cp maps every word in the set of all its circular permutations and every language in the set of all circular permutations of its words, while h is a morphism that erases # and leaves unchanged all letters of V . As the class of context-free languages is closed 2 under circular permutation [17], we infer that pHCk∗ (w) is context-free. The above argument does not work for the class of linear context-free languages as this class is known not to be closed under circular permutation. However, also this family is closed under iterated bounded hairpin completion. Theorem 2. The family of linear context-free languages is closed under iterated p-bounded k-hairpin completion for any k, p ≥ 1. Proof. Let L be a language generated by the linear grammar G = (N, T, S, P ). We construct the linear grammar G = (N  , T, S  , P  ), where N  = N ∪ {S  } ∪ {[α, β] | α, β ∈ T ∗ , 0 ≤ |α|, |β| ≤ k + p} ∪ {[α, A, β] | α, β ∈ T ∗ , 0 ≤ |α|, |β| ≤ k + p, A ∈ N }, and the set of productions P  is defined by (in the definition of every set α, β ∈ T ∗ , 0 ≤ |α|, |β| ≤ k + p, A ∈ N holds): P  = P ∪ {S  → S} ∪ {S  → [α, β] | α, β ∈ T ∗ , 0 ≤ |α|, |β| ≤ k + p} ∪ {[α, β] → [α , β  ]y R | α = α = yvw, β = uv R y R , |v| = k, |y| ≤ p, β  = xuv R , x ∈ T ∗ , |β  | ≤ k + p} ∪ {[α, β] → y[α , β  ]y R | α = yvw, β = β  = uv R y R , |v| = k, |y| ≤ p, α = vwx, x ∈ T ∗ , |α | ≤ k + p} ∪ {[α, β] → [α, S, β] | α, β ∈ T ∗ , 0 ≤ |α|, |β| ≤ k + p} ∪ {[α, A, β] → x[α , B, β  ]y | A → xBy ∈ P, α = xα , β = β  y, α , β  ∈ T ∗ } ∪ {[α, A, β] → αx[λ, B, β  ]y | A → αxBy ∈ P, β = β  y, β  ∈ T ∗ } ∪ {[α, A, β] → x[α , B, λ]yβ | A → xByβ ∈ P, α = xα , α ∈ T ∗ } ∪ {[λ, A, λ] → A | A ∈ N }.

Bounded Hairpin Completion

441

It is rather easy to note that we have the derivation S  =⇒∗ x[α, β]y =⇒ x[α, S, β]y =⇒∗ xαwβy in G if and only if S =⇒∗ αwβ in G and xαwβy ∈ pHCk∗ (αwβ). This concludes the proof. 2 The problem of whether or not the iterated unbounded hairpin completion of a word is context-free is open. By the previous result, it follows that the iterated bounded hairpin completion of a word is always linear context-free. We do not know whether this language is always regular. More generally, the status of the closure under iterated bounded hairpin completion of the class of regular languages remains unsettled. We finish this section with another general result. Theorem 3. Every trio closed under circular permutation and iterated finite substitution is closed under iterated bounded hairpin completion. Proof. We take two positive integers k, p ≥ 1. Let F be a family of languages with the above properties and L ⊆ V ∗ be a language in F . Let L1 be the circular permutation of L{#}, where # is a new symbol not in V . Clearly, L1 still lies in F . We consider the alphabet W = {[x#y] | x, y ∈ V ∗ , 0 ≤ |x|, |y| ≤ p + k} and define the morphism h : (W ∪ V )∗ −→ (V ∪ {#}∗ by h([x#y]) = x#y, for any [x#y] ∈ W , and h(a) = a, for any a ∈ V . We now consider the language L2 ∈ F given by L2 = h−1 (L1 ). By the closure properties of F , the language ∗ L3 = s∗ (L2 ) is in F , where s is the finite substitution s : (W ∪ V )∗ −→ 2(W ∪V ) defined by s(a) = {a}, a ∈ V, and s([x#y]) = {x#y} ∪ R with R = {[x#uR y] | x = vzu, y = z R w, u, v, z, w ∈ V ∗ , |z| = k, |uR y| ≤ p + k, |u| ≤ p} ∪ {[x#uR y  ]y  | x = vzu, y = z R w = y  y  , u, v, z, w, y  , y  ∈ V ∗ , |z| = k, |uR y  | = p + k, |u| ≤ p}} ∪ {[xuR #y] | x = wz R , y = uzv, u, v, z, w ∈ V ∗ , |z| = k, |xuR | ≤ p + k, |u| ≤ p}} ∪ {x [x uR #y] | x = wz R = x x , y = uzv, u, v, z, w, x , x ∈ V ∗ , |z| = k, |x uR | = p + k, |u| ≤ p}}. Finally, let L4 be the circular permutation of h(L3 ). Then we obtain that pHCk∗ (L) = g(L4 ∩ V ∗ {#}), where g is a morphism that removes # and leaves unchanged all symbols from V . 2

5

An Inverse Operation: The Bounded Hairpin Reduction

We now define the inverse operation of the bounded hairpin completion, namely the bounded hairpin reduction in a similar way to [13], where the unbounded hairpin reduction is introduced. Let V be an alphabet, for any w ∈ V + we define

442

M. Ito, P. Leupold, and V. Mitrana

the p-bounded k-hairpin reduction of w, denoted by pHRk (w), for some k, p ≥ 1, as follows: pHR k (w) = {αβαR γ R |w = γαβαR γ R , |α| = k, α, β, γ ∈ V + , 1 ≤ |γ| ≤ p}, pHR k (w) = {γαβαR |w = γαβαR γ R , |α| = k, α, β, γ ∈ V + , 1 ≤ |γ| ≤ p}. pHRk (w) = pHR k (w) ∪ pHR  (w). The p-bounded hairpin reduction of w is defined by  pHR(w) = pHRk (w). k≥1

The bounded hairpin reduction is naturally extended to languages by   pHRk (L) = pHRk (w) pHR(L) = pHR(w). w∈L

w∈L

The iterated bounded hairpin reduction is defined analogously to the iterated bounded hairpin completion. We recall that the problem of whether or not the iterated unbounded hairpin reduction of a regular language is recursively decidable is left open in [13]. The same problem for the iterated bounded hairpin reduction is now completely solved by the next more general result. Before stating the result, we need to recall a few notions about string-rewriting systems. To this aim, we follow the standard notations for string rewriting as in [2]. A string-rewriting system (SRS) over an alphabet V is a finite relation R ⊂ V ∗ × V ∗ , and the rewrite relation induced by R is denoted by −→R . That is, we write x −→R y if x = uvw, y = uzw, for some u, v, z, w ∈ V ∗ , and (v, z) ∈ R. As usual every pair (v, z) ∈ R is referred to as a rule v → z. The reflexive and transitive closure of −→R is denoted by −→∗R . We use R∗ (L) for the closure of the language L under the string-rewriting system R. Formally, R∗ (L) = {w | x −→∗R w, for some x ∈ L}. A rule v → z is said to be monadic if it is length-reducing (|v| > |z|) and |z| ≤ 1. A SRS is called monadic if all its rules are monadic. A class of languages F is closed under monadic SRS if for any language L ∈ F over some alphabet V and any monadic SRS R over V , R∗ (L) ∈ F holds. Theorem 4. Every trio closed under circular permutation and monadic stringrewriting systems is closed under iterated bounded hairpin reduction. Proof. Let F be a trio and k, p be two positive integers. The central idea of the proof is as follows. We permute every word of a language in F in a circular way. Then the last and first letters are next to each other. Thus the hairpin reduction becomes a local operation and can be simulated by monadic string-rewriting rules. By our hypothesis, these are known to preserve the membership in F . To start with, we attach a new symbol X to the end of every word of a given L ∈ F, L ⊆ V ∗ . Then we obtain the language L by doing a circular permutation to all words in L{X}. Note that X marks the end and beginning of

Bounded Hairpin Completion

443

the original words. On this language we apply a gsm-mapping g that introduces redundancy by adding to every letter information about its neighboring letters in the following way: 1. The letter containing the X contains also the k + p letters to the left and to the right of X in order. 2. Every letter left of X contains the letter originally at that position and the k + p letters left of it in order. 3. Every letter right of X contains the letter originally at that position and the k + p letters right of it in order. At the word’s end and its beginning, where there are not enough letters to fill the symbols, some special symbol signifying a space is placed inside the compound symbols. Now we can simulate a step of p-bounded k-hairpin reduction by a stringrewriting rule with a right-hand side of length one, i.e. a monadic one. A straightforward approach would be to use rules of the form uv R XvuR → uXvuR . But we see that u and XvuR are basically not changed, they only form a context whose presence is necessary. Through our redundant representation of the word, their presence can be checked by looking only at the corresponding image of X under g. Further, since the symbols of the image of u under g contain only information about symbols to their left, they do not need to be updated after the deletion of v R to preserve the properties 1 to 3. The same is true for vuR . Only in the symbol corresponding to X some updating needs to be done and thus it is the one that is actually rewritten. So the string rewriting rules are gleft (z0 z1 uv)[1 . . . |v|][z1 uvXvuz2 ] → [z0 z1 uXvuz2 ], where gleft does the part of g described by property 2, and where z0 , z1 ∈ V ∗ , u, v ∈ V + , |u| = k, |v| ≤ p, |z0 z1 u| = p+k. Analogously, rules that delete symbols to the right of X are defined. Let R be the string-rewriting system consisting of all such rules. It is immediate that w ∈ pHRk (w) ⇔ g(cp(wX)) →R g(cp(w X)) and by induction w ∈ pHRk∗ (w) ⇔ g(cp(wX)) →∗R g(cp(w X)). Therefore, at this point we have all circular permutations of words that can be reached by p-bounded k-hairpin reduction from words in L coded under g. To obtain our target language we first undo the coding of g by the gsm-mapping g  that projects all letters to the left of X to their last component, all letters to the right of X to their first component, and the symbol containing X to just X. This mapping is letter-to-letter, the gsm only needs to remember in its state whether is has already passes over the symbol containing X. Of the result of this we take again the circular permutation. Now we filter out the words that have X at the last position and therefore are back in the original order of L and delete X. By the closure properties of F , the result of this process lies in F , which completes the proof. 2 As monadic SRSs are known to preserve regularity (see [8]) we immediately infer that

444

M. Ito, P. Leupold, and V. Mitrana

Theorem 5. The class of regular languages is closed under iterated bounded hairpin reduction. In [12] one considers another concept that seems attractive to us, namely the primitive hairpin root of a word and of a language. Given a word x ∈ V ∗ and a positive integer k, the word y is said to be the primitive k-hairpin root of x if the following two conditions are satisfied: (i) y ∈ HRk∗ (x)(or, equivalent, x ∈ HCk∗ (y)), (ii) HRk (y) = ∅. Here HRk∗ (z) delivers the iterated unbounded hairpin reduction of the word z. In other words, y can be obtained from x by iterated k-hairpin reduction (maybe in zero steps) and y cannot be further reduced by hairpin reduction. The primitive bounded hairpin root is defined analogously. Clearly, a word may have more than one primitive bounded hairpin root; the set of all primitive p-bounded k-hairpin p-bounded roots of a word x is denoted by pHk root(x). Naturally, the primitive  k-hairpin root of a language L is defined by pHk root(L) = pHk root(x). x∈L

Clearly, to see whether a word is reducible, one has to look only at the first and last k + p symbols. By Theorem 5 we have: Theorem 6. pHk root(L) is regular for any regular language L and any p, k ≥ 1. Proof. For the regular language L ⊆ V ∗ obtained in the proof of Theorem 5 it suffices to consider the language R

{w ∈ L | |w| ≤ 2k + 2} ∪ (pHRk∗ (L) ∩ {αxβ | |α| = |β| = k + 1, α = β , x ∈ V + }) which is regular and equals pHk root(L).

6

2

Final Remarks

We have considered a restricted version of the hairpin completion operation by imposing that the prefix or suffix added by the hairpin completion are bounded by a constant. In some sense, this is the lower extreme case the upper extreme being the unbounded case that might be viewed as a linearly bounded variant. We consider that bounded variants by other sublinear mappings would be of theoretical interest. Last but not least we would like to mention that hairpin completion and reduction resemble some language generating mechanisms considered in the literature like external contextual grammars with choice [15] or dipolar contextual deletion [9], respectively.

References 1. Baker, B.S.: Context-sensitive grammars generating context-free languages. In: Automata, Languages and Programming ICALP 1972, pp. 501–506. North-Holland, Amsterdam (1972) 2. Book, R., Otto, F.: String-Rewriting Systems. Springer, Heidelberg (1993)

Bounded Hairpin Completion

445

3. Bottoni, P., Labella, A., Manca, V., Mitrana, V.: Superposition based on WatsonCrick-like complementarity. Theory of Computing Systems 39, 503–524 (2006) 4. Cheptea, D., Mart´ın-Vide, C., Mitrana, V.: A new operation on words suggested by DNA biochemistry: hairpin completion. In: Transgressive Computing, pp. 216–228 (2006) 5. Deaton, R., Murphy, R., Garzon, M., Franceschetti, D.R., Stevens, S.E.: Good encodings for DNA-based solutions to combinatorial problems. In: Proc. of DNAbased computers II. DIMACS Series, vol. 44, pp. 247–258 (1998) 6. Garzon, M., Deaton, R., Neathery, P., Murphy, R.C., Franceschetti, D.R., Stevens, S.E.: On the encoding problem for DNA computing. In: The Third DIMACS Workshop on DNA-Based Computing, pp. 230–237. Univ. of Pennsylvania (1997) 7. Garzon, M., Deaton, R., Nino, L.F., Stevens, S.E., Wittner, M.: Genome encoding for DNA computing. In: Proc. Third Genetic Programming Conference, Madison, MI, pp. 684–690 (1998) 8. Hofbauer, D., Waldmann, J.: Deleting string-rewriting systems preserve regularity. Theoretical Computer Science 327, 301–317 (2004) 9. Kari, L., Thierrin, G.: Contextual insertions/deletions and computability. Information and Computation 131, 47–61 (1996) 10. Kari, L., Konstantinidis, S., Sos´ık, P., Thierrin, G.: On hairpin-free words and languages. In: De Felice, C., Restivo, A. (eds.) DLT 2005. LNCS, vol. 3572, pp. 296–307. Springer, Heidelberg (2005) 11. Manea, F., Mart´ın-Vide, C., Mitrana, V.: On some algorithmic problems regarding the hairpin completion. Discrete Applied Mathematics (in press), doi:10.1016/j.dam.2007.09.022 12. Manea, F., Mitrana, V.: Hairpin completion versus hairpin reduction. In: Cooper, S.B., L¨ owe, B., Sorbi, A. (eds.) CiE 2007. LNCS, vol. 4497, pp. 532–541. Springer, Heidelberg (2007) 13. Manea, F., Mitrana, V., Yokomori, T.: Two complementary operations inspired by the DNA hairpin formation: completion and reduction. Theoretical Computer Science (in press), doi:10.1016/j.tcs.2008.09.049 14. Manea, F., Mitrana, V., Yokomori, T.: Some remarks on the hairpin completion. In: Proc. 12th International Conference on Automata and Formal Languages, pp. 302–313 (2008) 15. Marcus, S.: Contextual grammars. Rev. Roum. Math. Pures Appl. 14, 1525–1534 (1969) 16. Rozenberg, G., Salomaa, A. (eds.): Handbook of Formal Languages. Springer, Heidelberg (1997) 17. Ruohonen, K.: On circular words and (ω ∗ + ω)-powers of words. Elektr. Inform. und Kybern. E.I.K. 13, 3–12 (1977) 18. Sakamoto, K., Gouzu, H., Komiya, K., Kiga, D., Yokoyama, S., Yokomori, T., Hagiya, M.: Molecular computation by DNA hairpin formation. Science 288, 1223– 1226 (2000) 19. Salomaa, A.: Formal Languages. Academic Press, London (1973)

Rigid Tree Automata Florent Jacquemard1, Francis Klay2 , and Camille Vacher3 1

INRIA Saclay & LSV (CNRS/ENS Cachan) [email protected] 2 FT/RD/MAPS/AMS/SLE [email protected] 3 FT/RD & LSV (CNRS/ENS Cachan) [email protected]

Abstract. We introduce the class of Rigid Tree Automata (RTA), an extension of standard bottom-up automata on ranked trees with distinguished states called rigid. Rigid states define a restriction on the computation of RTA on trees: RTA can test for equality in subtrees reaching the same rigid state. RTA are able to perform local and global tests of equality between subtrees, non-linear tree pattern matching, and restricted disequality tests as well. Properties like determinism, pumping lemma, boolean closure, and several decision problems are studied in detail. In particular, the emptiness problem is shown decidable in linear time for RTA whereas membership of a given tree to the language of a given RTA is NP-complete. Our main result is the decidability of whether a given tree belongs to the rewrite closure of a RTA language under a restricted family of term rewriting systems, whereas this closure is not a RTA language. This result, one of the first on rewrite closure of languages of tree automata with constraints, is enabling the extension of model checking procedures based on finite tree automata techniques. Finally, a comparison of RTA with several classes of tree automata with local and global equality tests, and with dag automata is also provided.

Introduction Tree automata (TA) are finite representations of infinite sets of terms. In system and software verification, TA can be used to represent infinite sets of states of a system or a program (in the latter case, a term can represent the program itself), messages exchanged by a protocol, XML documents... In these settings, the closure properties of TA languages permit incremental constructions and verification problems can be reduced to TA problems decidable in polynomial time like emptiness (is the language recognized by a given TA empty) and membership (is a given term t recognized by a given TA). Despite these nice properties, a big limitation of TA is their inability to test equalities between subterms during their computation: TA are able to detect linear patterns like fst(pair(x1 , x2 )) but not a pattern like pair(x, x). Several extensions of TA have been proposed to overcome this problem, by addition 

´ This work was partly supported by the ANR Sesur 07 project AVOTE.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 446–457, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Rigid Tree Automata

447

of equality and disequality tests in TA transition rules (the classes [1,2] have a decidable emptiness problem), or an auxiliary memory containing a tree and memory comparison [3]. However, they are all limited to local tests, at a bounded distance from the current position. In this paper, we define the rigid tree automata (RTA) by the identification of some states as rigid, and the condition that the subterms recognized in one rigid state during a computation are all equal. With such a formalism, it is possible to check local and global equality tests between subterms, and also the subterm relation or restricted disequalities. In Sections 2 and 3 we study issues like determinism, closure of languages under Boolean operations, comparison with related classes of automata and decision problems for RTA. RTA are a particular case of the more general class Tree Automata with General Equality and Disequality constraints (TAGED [4]). The study of the class RTA alone is motivated by the complexity results and applications mentioned below. But our most original contribution is the study of the rewrite closure of RTA languages. Combining tree automata and term rewriting techniques has been very successful in verification see e.g. [5,6]. In this context, term rewriting systems (TRS) can describe the transitions of a system, the evaluation of a program [5], the specification of operators used to build protocol messages [7] or also the trans formation of documents. In these approaches, the rewrite closure R∗ L(A) of the language L(A) of a TA A using R represents   the set of states reachable from states described by L(A). When R∗ L(A) is again a TA language, the verificationof a safety property amounts to check for the existence of an error  state in R∗ L(A) (either a given term t or a term in a given regular language). This technique, sometimes referred as regular tree model checking, has driven a lot of attention to the rewrite closure of tree automata languages. However, there has been very few studies of this issue for constrained TA (see e.g. [8]). In Section 4, we show that it is decidable whether a given term t belongs to the rewrite closure of a given RTA language for a restricted class of TRS called linear invisibly, whereas this closure is generally not a RTA language. Linear invisibly TRS can typically specify cryptographic operators like decrypt(encrypt(x, pk(A)), sk(A)) → x. Using RTA instead of TA in a regular tree model checking procedure permits to handle processes with local and global memories taking their values in infinite domains and which can be written only once. For instance, our initial motivation for studying RTA was the analysis of security protocols in a model where a finite number of processes exchange messages (following a protocol) asynchronously over an insecure network controlled by an attacker who is able to tamper the messages. The messages are terms build over cryptographic operators and are interpreted modulo an invisibly TRS R with rules like the above one for decrypt [7]. It is possible to built a RTA A recognizing exactly the set of messages that can be exchanged by executing the protocol in presence of the active attacker. The RTA A models both the honest processes and the attacker, and uses one rigid state to memorize each message sent by an honest process In these settings, it is possible to express confidentiality problems as membership

448

F. Jacquemard, F. Klay, and C. Vacher

  modulo R (does t ∈ R∗ L(A) ), and authentication like problems as emptiness of intersection with a TA (does L(A) ∩ L(B) = ∅ for a TA B recognizing error traces). All the details and proofs omitted in this extended abstract due to space restrictions can be found in the long version [9].

1

Preliminaries

A signature Σ is a finite set of function symbols with arity. We write Σm for the subset of function symbols of Σ of arity m. Given an infinite set X of variables, the set of terms built over Σ and X is denoted T (Σ, X ), and the subset of ground terms (terms without variables) is denoted T (Σ). The set of variables occurring in a term t ∈ T (Σ, X ) is denoted vars(t). A term t ∈ T (Σ, X ) is called linear if every variable of vars(t) occurs at most once in t. A substitution σ is a mapping from X to T (Σ, X ).The application of a substitution σ to a term t is the homomorphic extension of σ to T (Σ, X ). A term t can be seen as a function from its set of positions Pos(t) into function symbols of variables of Σ ∪ X . The positions of Pos(t) are sequences of positive integers (ε, the empty sequence, is the root position). Position are compared wrt the prefix ordering: p1 < p2 iff there exists p = ε such that p2 = p1 .p. In this case, p is denoted p2 − p1 . A subterm of t at position p is written t|p , and the replacement in t of the subterm at position p by u is denoted t[u]p . The depth d (t) of t is the length of its longest position. A n-context is a linear term of T (Σ, {x1 , . . . , xn }). The application of a n-context C to n terms t1 , . . . , tn , denoted by C[t1 , . . . , tn ], is defined as the application to C of the substitution {x1 → t1 , . . . , xn → tn }. Term Rewriting. A term rewrite system (TRS) over a signature Σ is a finite set of rewrite rules  → r, where  ∈ T (Σ, X ) (it is called the left-hand side (lhs) of the rule) and r ∈ T (Σ, vars()) (it is called right-hand-side (lhs)). A term t ∈ T (Σ, X ) rewrites to s by a TRS R (denoted t −− → s ) if there is a rewrite R rule  → r ∈ R, a position p ∈ Pos(t) and a substitution σ such that t|p = σ() and s = t[σ(r)]p . In this case, t is called reducible. An irreducible term is also called an R-normal-form. The transitive and reflexive closure of −− → is denoted R  ∗ ∗ ∗  ∃s ∈ L, s −− → . Given L ⊆ T (Σ, X ), we note R (L) = {t t}. A TRS is −− → R R called linear if all the terms in its rules are linear and collapsing if every rhs of rule is a variable. Tree Automata. A tree automaton (TA) A on a signature Σ is a tuple Q, F, Δ where Q is a finite set of nullary state symbols, disjoint from Σ, F ⊆ Q is the subset of final states and Δ is a set of transition rules of the form: f (q1 , . . . , qn ) → q where n ≥ 0, f ∈ Σn , and q1 , . . . , qn , q ∈ Q. The size of A is the number of symbols in Δ. A run of the TA A on a term t ∈ T (Σ) is a function r : Pos(t) →   Q such that for all p ∈ Pos(t) with t(p) = f ∈ Σn (n ≥ 0), f r(p.1), . . . , r(p.n) → r(p) ∈ Δ. We will sometimes use term-like notation for runs. For instance, a run {ε → q, 1 → q1 , 2 → q2 } will be denoted q(q1 , q2 ).

Rigid Tree Automata

449

The language L(A, q) of a TA A in state q is the set of ground terms for which there exists a run r of A such that r(ε)  = q. If q ∈ F then this run r is called successful. The language L(A) of A is q∈F L(A, q), and a set of ground terms is called regular if it is the language of a TA. A TA A = Q, F, Δ on Σ is deterministic (DTA), resp. complete, if for every f ∈ Σn , and every q1 , . . . , qn ∈ Q, there exists at most, resp. at least, one rule f (q1 , . . . , qn ) → q ∈ Δ. In the deterministic (resp. complete) cases, given a tree t, there is at most (resp. at least) one run r of A on t.

2 2.1

RTA: Definition and First Properties Definition and Examples

Definition 1. A rigid tree automaton (RTA) A on a signature Σ is a tuple Q, R, F, Δ where Q, F, Δ is a tree automaton denoted ta(A) and R ⊆ Q is the subset of rigid states. A run of the RTA A on a term t ∈ T (Σ) is a run r of the underlying TA ta(A) on t with the additional condition that: for all positions p1 , p2 ∈ Pos(t), if r(p1 ) = r(p2 ) ∈ R then t|p1 = t|p2 . Languages of RTA are defined the same way as for TA. Note that with these definitions, every regular language is a RTA language. We shall write below TA and RTA for the classes of TA and RTA languages. Example 1. Let Σ = {a : 0,  b : 0, f : 2}. The set {f (t, t) | t ∈ T (Σ)} is recognized by the RTA on Σ A = {q, qr , qf }, {qr }, {qf }, {a → q|qr , b → q|qr , f (q, q) → for a → q|qr , f (qr , qr ) → qf } , where a → q|qr is an abbreviation   q and a → qr . A successful run of A on f (f (a, b), f (a, b)) is qf qr (q, q), qr (q, q) . 3 Note that the above RTA language is not regular; RTA generalize to non-linear pattern the (linear) pattern matching ability of TA. Example 2. Let us extend the RTA of Example 1 with the transitions rules f (q, qf ) → qf , f (qf , q) → qf ensuring the propagation of the final state qf up to the root. The RTA obtained recognizes the set of terms of T (Σ) containing the pattern f (x, x). 3 Proposition 1. For all term t ∈ T (Σ, X ), there exists a RTA recognizing the terms of T (Σ) which have a ground instance of t as a subterm. But RTA are not limited to testing equalities. Using rigid states permits to test disequality and inequality as well, like the subterm relation. Example 3. Let  Σ = {a  : 0, b : 0, f : 2, < :2}. The set of terms 0, w ∈ Γ ∗ }1 where 1 ≤ i1 , . . . , im ≤ n. Let R be a TRS on Σ with the rules fi (gi (ui (x))) → x (i ≤ n), gi (x) → x (i ≤ n), gj (fi (vi (x))) → x (i, j ≤ n), and k(fi (vi (x))) → x (i ≤ n). The tree language L is recognizable by a RTA on Σ and we show [9]   that h(0, 0) ∈ R∗ (L) iff P has a solution. The problem of Theorem 10, membership modulo, becomes decidable with some further syntactical restrictions on R based on the theory of visibly pushdown automata (VPA) [15]. VPA define a subset of context-free languages closed under intersection, and were generalized to tree recognizers in [16,17]. The idea in these works is that the signature Σ is partitioned into Σ = Σc  Σr  Σ and the operation performed by the VPA on the stack depends on the current symbol in input: if it is a call symbol of Σc , the VPA can only do a push, for a return symbol of Σr it can do a pop and it must leave the stack untouched for a local symbol of Σ . In [16], Chabin and Rety show that the class of visibly pushdown tree automata (VPTA) languages is closed under rewriting with so called linear contextfree visibly TRS. We use a similar definition in order to characterize a class of TRS for which membership modulo is decidable. Definition 2. A collapsing TRS R is called inverse-visibly (invisibly) if for every rule  → x ∈ R, d () ≥ 1, x occurs once in , and if x occurs at depth 1 in  then  ∈ T (Σ , X ), otherwise, (ε) ∈ Σc , the symbol immediately above x is in Σr and all the other symbols of  are in Σ . Example 7. The TRS R = {fst(pair(x1 , x2 )) → x1 , snd(pair(x1 , x2 )) → x2 , decrypt(encrypt(x, pk(A)), sk(A)) → x} is linear and invisibly with Σc = 3 {fst, snd, decrypt} and Σr = {pair, encrypt}, Σ = {pk, sk, A}. The TRS {f (g(x)) → x} is invisibly but not the one for Theorem 10. Theorem 11. The problem to know whether t ∈ R∗ (L(A)) or not, given a RTA A, a linear and invisibly TRS R and a term t, is decidable. Proof. The proof [9] is long and technical, and due to space restrictions, we only sketch it below for a TRS R containing the two first rewrite rules of Example 7. 1

For all w = a1 , . . . , ap ∈ Γ ∗ , the term a1 (. . . ap (t)) is written w(t).

456

F. Jacquemard, F. Klay, and C. Vacher

Let A = Q, R, F, Δ be a RTA on Σ = {f : 2, fst : 1, snd : 1, pair : 2, 0 : 0} with Q = {q0 , qr , q1 , qf }, R = {qr }, F = {qf }, and Δ = {0 → q0 , pair(q0 , q0 ) → q0 |qr , fst(qr |q1 ) → q1 , snd(qr |q1 ) → q1 , f(q1 , q1 ) → qf } and let t = f(pair(0, 0), 0). Very roughly, the decision algorithm guesses the existence of one tree t ∈ L(A) ∗ such that t −− → t, by application of R backwards starting from t, expanding R subterms into lhs of rules. In order to ensure that t ∈ L(A), we consider pairs of states qqxε which intuitively correspond to a run r of A on  (for  → x ∈ R) such that qε = r(ε) and qx = r(px ) where (px ) = x (this position px is unique by hypothesis). If qε = qx , the pair is simply denoted qε . In a first step, we label the lhs of R with such pairs. For both fst(pair(x1 , x2 )) and snd(pair(x1 , x2 )), the only possible labelling is 1 := q1 ( qq10 (q0 , q0 )). The condition for such a labelling is indeed that there exists a transition in A from the first components of labels at sibling positions into the second component of the label at the father position, like fst(q1 ) → q1 and pair(q0 , q0 ) → q0 for 1 above. Intuitively, 1 describes a nesting of runs on lhs of R which permits to recover a run r of A on t . In other terms, t can be generated by a context-free tree grammar with non-terminals from Q (nullary) or of the form qqxε (unary). For instance, the production rule  q1 q1 q0 (x) := fst( q0 (pair(x, q0 ) corresponds to fst(pair(x1 , x2 )) → x1 . The grammar generates a visibly pushdown tree language, thanks to the hypotheses on R. Next, in order to guess t , we label the positions of t by pairs of states. We obtain qf (p(q0 , q0 ), qq10 ) where p is either qr or qq10 . We can observe that the rigid state qr occurs, possibly at nested depth bigger than one, in both cases for p. The tricky part of the algorithm it to check that there exists at least one term in the intersection of the languages (generated by grammars as above) corresponding to the distinct occurrences of qr . We use the fact that the emptiness of intersection is decidable for visibly context free tree grammars.  

5

Conclusion and Further Work

We want to use RTA for the automatic verification of traces or equivalence properties of security protocols, using regular tree model checking like techniques. In this context, we are planning to extend the result of Theorem 11 to invisibly (non-linear) TRS, in order to handle axioms as decrypt(encrypt(x, y), y) = x. We are also interested about the symmetric form of the TRS of [16], whose rhs are not single variables but have the form f (x1 , . . . , xn ). One may also study the extension of RTA to equality tests modulo equational theories like in [8], or the addition of disequality constraints in order to obtain closure under complement and correspondence with logics.

References 1. Bogaert, B., Tison, S.: Equality and Disequality Constraints on Direct Subterms in Tree Automata. In: Finkel, A., Jantzen, M. (eds.) STACS 1992. LNCS, vol. 577, pp. 161–171. Springer, Heidelberg (1992) 2. Dauchet, M., Caron, A.C., Coquid´e, J.L.: Automata for Reduction Properties Solving. Journal of Symbolic Computation 20(2), 215–233 (1995)

Rigid Tree Automata

457

3. Comon, H., Cortier, V.: Tree automata with one memory, set constraints and cryptographic protocols. Theoretical Computer Science 331(1), 143–214 (2005) 4. Filiot, E., Talbot, J.M., Tison, S.: Tree automata with global constraints. In: Ito, M., Toyama, M. (eds.) DLT 2008. LNCS, vol. 5257, pp. 314–326. Springer, Heidelberg (2008) 5. Bouajjani, A., Touili, T.: On computing reachability sets of process rewrite systems. In: Giesl, J. (ed.) RTA 2005. LNCS, vol. 3467, pp. 484–499. Springer, Heidelberg (2005) 6. Genet, T., Klay, F.: Rewriting for Cryptographic Protocol Verification. In: McAllester, D. (ed.) CADE 2000. LNCS, vol. 1831. Springer, Heidelberg (2000) 7. Abadi, M., Fournet, C.: Mobile values, new names, and secure communication. In: 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL, pp. 104–115 (2001) 8. Jacquemard, F., Rusinowitch, M., Vigneron, L.: Tree automata with equality constraints modulo equational theories. Journal of Logic and Algebraic Programming 75(2), 182–208 (2008) 9. Jacquemard, F., Klay, F., Vacher, C.: Rigid tree automata. Technical Report RRLSV-0827, Laboratoire Sp´ecification et V´erification (2008) 10. Filiot, E., Talbot, J.M., Tison, S.: Satisfiability of a spatial logic with tree variables. In: Duparc, J., Henzinger, T.A. (eds.) CSL 2007. LNCS, vol. 4646, pp. 130–145. Springer, Heidelberg (2007) 11. Charatonik, W.: Automata on dag representations of finite trees. Technical Report Technical Report MPI-I-99-2-001, Max-Planck-Institut f¨ ur Informatik, Saarbr¨ ucken, Germany (1999) 12. Anantharaman, S., Narendran, P., Rusinowitch, M.: Closure properties and decision problems of dag automata. Inf. Process. Lett. 94(5), 231–240 (2005) 13. Comon, H., Dauchet, M., Gilleron, R., Jacquemard, F., L¨ oding, C., Lugiez, D., Tison, S., Tommasi, M.: Tree Automata Techniques and Applications (2007), http://tata.gforge.inria.fr 14. Seidl, H.: Haskell overloading is DEXPTIME-complete. Information Processing Letters 52(2), 57–60 (1994) 15. Alur, R., Madhusudan, P.: Visibly pushdown languages. In: 36th Annual ACM Symposium on Theory of Computing, STOC, pp. 202–211. ACM, New York (2004) 16. Chabin, J., R´ety, P.: Visibly pushdown languages and term rewriting. In: Konev, B., Wolter, F. (eds.) FroCos 2007. LNCS, vol. 4720, pp. 252–266. Springer, Heidelberg (2007) 17. Comon-Lundh, H., Jacquemard, F., Perrin, N.: Tree automata with memory, visibility and structural constraints. In: Seidl, H. (ed.) FOSSACS 2007. LNCS, vol. 4423, pp. 168–182. Springer, Heidelberg (2007)

Converting Self-verifying Automata into Deterministic Automata Galina Jir´ askov´a1, and Giovanni Pighizzini2, 1

Mathematical Institute, Slovak Academy of Sciences, Greˇs´ akova 6, 040 01 Koˇsice, Slovakia [email protected] 2 Dipartimento di Informatica e Comunicazione, Universit` a degli Studi di Milano via Comelico 39, I-20135 Milano, Italy [email protected]

Abstract. Self-verifying automata are a special variant of finite automata with a symmetric kind of nondeterminism. In this paper, we study the transformation of self-verifying automata into deterministic automata from a descriptional complexity point of view. The main result is the exact cost, in terms of the number of states, of such a simulation.

1

Introduction

In automata theory and theoretical computer science, several kinds of devices able to recognize formal languages have been proposed and investigated. Different classes of devices can be compared, first of all, from the point of view of their recognition powers. We mention just two examples of classical results in this area: the equivalence between deterministic and nondeterministic finite automata, and the fact that deterministic pushdown automata are strictly less powerful than nondeterministic ones. With a deeper investigation, classes of devices can be compared from the point of view of their descriptional complexity [1]. The classical example is the simulation of n-state nondeterministic automata by deterministic automata that can be done using 2n states [2], and cannot be done, in the worst case, with less than 2n states [3,4,5]. In this paper, we continue this line of research, by considering self-verifying automata, a special kind of finite automata, introduced in [6], with a symmetric form of nondeterminism, called self-verifying nondeterminism [7]. This kind of nondeterminism was mainly considered in connection with randomized Las Vegas computations, but as pointed out in [8], it is interesting also per se. Roughly speaking, in self-verifying nondeterminism, computation paths can give three types of answers: yes, no, and I do not know. On each input string,  

Supported by VEGA grant 2/0111/09. Partially supported by MIUR under the project PRIN “Aspetti matematici e applicazioni emergenti degli automi e dei linguaggi formali: metodi probabilistici e combinatori in ambito di linguaggi formali”.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 458–468, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Converting Self-verifying Automata into Deterministic Automata

459

at least one path must give answer “yes” or “no”. Furthermore, on the same string, two paths cannot give contradictory answers, namely both the answers “yes” and “no” are not possible. It is not difficult to observe that self-verifying automata are as powerful as deterministic automata. In particular, the standard subset construction can be used to convert them to deterministic automata. Hence, the question arises of investigating this equivalence from the descriptional point of view. This problem was previously considered by Assent and Seibert in [9], who proved that in the deterministic automaton obtained by applying the standard subset construction to a self-verifying automaton certain states must be equivalent. As a consequence, they were able to show that each n-state self-verifying 2n ) states. automaton can be simulated by a deterministic automaton with O( √ n In this paper, we further deepen this investigation by showing that such an n upper bound can be lowered to a function g(n) which grows like 3 3 (we give the exact value of g(n) in the paper). In particular, we associate with each nstate self-verifying automaton A a certain graph with n vertices, and we prove that there exists a deterministic automaton equivalent to A whose state set is isomorphic to the set of the maximal cliques of such a graph. Using a result from graph theory stating the number of possible maximal cliques in a graph [10], we get the upper bound g(n). In the second part of the paper, we prove the optimality of such an upper bound. In fact, we are able to show that for each positive integer n, there exists a binary language L accepted by an n-state self-verifying automaton, such that the minimal equivalent deterministic automaton must have exactly g(n) states. We conclude the paper with some considerations concerning the cases of automata defined over a one-letter alphabet and of automata with multiple initial states.

2

Preliminaries

We fix an alphabet Σ. Given a language L ⊆ Σ ∗ , we denote by Lc the complement of L, namely the set Σ ∗ − L. We assume that the reader is familiar with the notions of deterministic and nondeterministic finite automata (denoted respectively as dfa’s and nfa’s, for short). Definition 1. A self-verifying finite automaton (svfa) A is a 6-tuple (Q, Σ, δ, q0 , F a , F r ), where Q, Σ, δ, q0 are defined as for standard nondeterministic automata, F a , F r ⊆ Q are, respectively, the sets of accepting and rejecting states, while the remaining states, namely the states belonging to Q − (F a ∪ F r ), are called neutral states. It is required that for each input string w in Σ ∗ , there exists at least one computation ending in an accepting or in a rejecting state, that is, δ(q0 , w) ∩ (F a ∪ F r ) = ∅, and there are no strings w such that both δ(q0 , w) ∩ F a and δ(q0 , w) ∩ F r are nonempty.

460

G. Jir´ askov´ a and G. Pighizzini

The language accepted by A, denoted as La (A), is the set of all input strings having a computation ending in an accepting state, while the language rejected by A, denoted as Lr (A), is the set of all input strings having a computation ending in a rejecting state. It follows directly from the definition that La (A) = (Lr (A))c for each svfa A. Hence, when we will say that an svfa A recognizes a language L, we will mean that L = La (A) and Lc = Lr (A). From an svfa A recognizing a language L, we can immediately get two nfa’s accepting, respectively, L and Lc . These automata are defined like the svfa A, except that the sets of final states are replaced, respectively, by F a and F r . Hence, svfa’s can be seen as a special case of nfa’s. On the other hand, having two nfa’s accepting languages L and Lc , respectively, we can construct an svfa for the language L by adding a new initial state connected via ε-transitions to the initial states of the two nfa’s. The set of accepting states of this svfa consists of all final states of the nfa for L, while the set of rejecting states contains all final states of the nfa for Lc . The above observations give the following relationships between the sizes of svfa’s and nfa’s recognizing the same language. Theorem 1 ([8, Observation 4.2]). For each regular language L, let ns(L) and svs(L) denote, respectively, the minimum number of states of any nfa and of any svfa recognizing L. Then max {ns(L), ns(Lc )}  svs(L)  1+ns(L)+ns(Lc ). Let G = (V, E) be an undirected graph. We recall that each complete subgraph of G is called a clique. We also say that a subset α ⊆ V forms a clique if the subgraph of G induced by α, namely the graph (α, E ∩ (α × α)), is a clique. Furthermore, a clique α ⊆ V is maximal if each subset properly containing α does not form a clique. In [10], Moon and Moser stated the following exact bound for the number of maximal cliques in a graph. Theorem 2 (Moon, Moser [10]). Let f (n) denotes the maximum number of possible maximal cliques in a graph with n nodes. If n  2, then ⎧ n if n ≡ 0 (mod 3), ⎨3 3 , n f (n) = 4 · 3 3 −1 , if n ≡ 1 (mod 3), n ⎩ 2 · 3 3  , if n ≡ 2 (mod 3).

3

Conversion of svfa’s into dfa’s

Self-verifying automata are a special case of nondeterministic automata. Hence, the standard simulation of nfa’s by dfa’s given by the subset construction can be used also to simulate svfa’s. In this section, by investigating some properties of svfa’s and of the corresponding subset automata, we will show how it is possible to reduce the number of states of resulting dfa’s. More precisely, the main result of this section is an upper bound on the number of states of minimal dfa’s equivalent to n-state svfa’s.

Converting Self-verifying Automata into Deterministic Automata

461

Throughout the section, consider a fixed svfa A = (Q, Σ, δ, q0 , F a , F r ) with n states. Given a state q ∈ Q, we denote by Laq and Lrq , respectively, the set of strings accepted and the set of strings rejected starting from q, that is, Laq = {x ∈ Σ ∗ | δ(q, x) ∩ F a = ∅} and Lrq = {x ∈ Σ ∗ | δ(q, x) ∩ F r = ∅}. We observe that as a consequence of the definition of svfa’s, the following statements hold for the initial state q0 : • Laq0 ∪Lrq0 = Σ ∗ , namely the automaton A must give an answer on each string (completeness). • Laq0 ∩ Lrq0 = ∅, namely the automaton A cannot give two contradictory answers on the same string (consistency). Note that the conjunction of the two statements is equivalent to Laq0 = (Lrq0 )c . If q ∈ Q is a reachable state of A, namely there exists a string x in Σ ∗ such that q ∈ δ(q0 , x), then Laq ∩ Lrq = ∅. Otherwise, if q is not reachable, it is possible that the languages Laq and Lrq are not disjoint. However, we can remove all unreachable states from A, without affecting the accepted and the rejected languages. Hence, in the following we assume that each state q of A is reachable and so Laq ∩ Lrq = ∅. Applying the standard subset construction to the svfa A, we get an equivalent dfa. Such a dfa, restricted to its reachable states, i.e., to states α ⊆ Q such that there is at least one string x ∈ Σ ∗ with δ(q0 , x) = α, will be called in the following the subset automaton associated with A. While for a state q = q0 of an svfa it can happen that starting from q and reading a string x neither accepting nor rejecting states are reachable, that is, x∈ / Laq ∪ Lrq , for the states of the subset automaton we can prove a completeness condition. In particular, for each α ⊆ Q, weconsider the languages  accepted and rejected starting from α given by Laα = q∈α Laq and Lrα = q∈α Lrq , and we prove the following lemma. Lemma 1. Let α ⊆ Q be a state of the subset automaton. Then Laα ∩ Lrα = ∅ and Laα ∪ Lrα = Σ ∗ , i.e., Laα = (Lrα )c . Proof. Since α is a state of the subset automaton, it must be reachable. Let x be a string in Σ ∗ such that δ(q0 , x) = α. Suppose that y ∈ Laα ∩ Lrα . Then δ(q0 , xy) ∩ F a = ∅ and δ(q0 , xy) ∩ F r = ∅, which is a contradiction. / Laq0 ∪ Lrq0 , which is a In a similar way, if y ∈ / Laα ∪ Lrα , then we get that xy ∈ contradiction.

In order to state an upper bound on the number of states of the minimal dfa equivalent to A, it is useful to count how many reachable subsets of Q, representing different languages, are possible, or to find equivalence conditions for the states of the subset automaton. In [9] it was shown that given two reachable states α, β ⊆ Q of the subset automaton, α ⊆ β implies that α and β are equivalent. In light of Lemma 1, this is due to the fact that α ⊆ β implies that Laα ⊆ Laβ and Lrα ⊆ Lrβ , which combined with the completeness conditions of the lemma, gives Laα = Laβ and

462

G. Jir´ askov´ a and G. Pighizzini

Lrα = Lrβ . In the following, we will show that actually in the subset automaton the state equivalence is implied by a weaker condition. To this aim, we introduce a compatibility relation on the state set Q. Intuitively, two states q, p ∈ Q are compatible if and only if two computations starting from q and p cannot give contradictory answers on the same string. We now define this notion formally. Definition 2. Two states q, p ∈ Q are compatible if and only if (Laq ∪ Lap ) ∩ (Lrq ∪ Lrp ) = ∅. The compatibility graph of A is the undirected graph whose vertex set is Q, and which contains an edge {q, p} if and only if states q and p are compatible. By the above discussion, it is immediate to observe that if α is a state of the subset automaton, then all q, p ∈ α must be compatible. Hence, each reachable state of the subset automaton is represented by a clique in the compatibility graph. The following lemma allows us to restrict our attention only to maximal cliques. Lemma 2. Let α, β ⊆ Q be two states of the subset automaton such that α ∪ β is a clique in the compatibility graph of the svfa A. Then α and β are equivalent. Proof. Before proving the lemma, we notice that at the first glance the statement seems to be very close to Claim 3.2 in [9]. However, that claim does not apply when α ∪ β is not a reachable state of the subset automaton. By contradiction, assume that there is a string x in Σ ∗ which is accepted by the subset automaton from state α and rejected from state β. It follows that there is a state q in α and a state p in β such that the string x is accepted by the svfa A from state q and rejected from state p. This means that states q and p are not compatible, which contradicts our assumption that α ∪ β is a clique in the compatibility graph of A.

Now we are able to state our upper bound. Theorem 3. For each svfa A with n states, there exists an equivalent dfa with at most 1 + f (n − 1) states, where f (n) is the maximum number of possible maximal cliques in a graph with n nodes. Proof. We have already observed that each state of the subset automaton associated with A is a clique in the compatibility graph of A. Furthermore, by Lemma 2, if two states form cliques that are contained in the same maximal clique, then they are equivalent. Hence, the subset automaton can be reduced to an equivalent dfa with at most one state for each maximal clique of the compatibility graph. To complete the proof, we count the number of such cliques. First of all, we observe that since Laq0 = (Lrq0 )c , two states q and p that are compatible with the initial state q0 are compatible with each other. Hence, in the compatibility graph there is exactly one maximal clique containing state q0 , while the other maximal cliques can involve the remaining n − 1 states. Hence, using Theorem 2, we get that the minimal dfa equivalent to A can have at most 1 + f (n − 1) states.



Converting Self-verifying Automata into Deterministic Automata

4

463

Optimality

In this section, we study the optimality of the simulation of svfa’s by dfa’s presented in Section 3. We prove that for each n, there exists a binary svfa An with n states whose equivalent minimal dfa has 1 + f (n − 1) states, showing in this way a lower bound exactly matching the upper bound stated in Theorem 3. For the sake of simplicity, let us start by considering the case n = 1 + 3m, with m  2. In the last part of the section, we will discuss how to extend our argument to the other values of n. Let An = (Q, {a, b}, δ, q0 , F a , F r ) be the automaton depicted in Figure 1 and defined as follows: • Q = {q0 } ∪ {(i, j) | 0  i  2, 1  j  m}, • δ(q0 , a) = δ(q0 , b) = {(0, 1), (0, 2), . . . , (0, m)}, and for all i,  j with 0  i  2 and 1  j  m, {(i, j + 1)}, if j < m, δ((i, j), a) = {(0, 1)}, otherwise, δ((i, j), b) = {((i + 1) mod 3, j)}, • F a = {q0 , (0, m)}, F r = {(1, m), (2, m)}.

 yes @ R  q0 Z    Z a, b  a, b a, bZ Z  Z    ~  Z     a a a   - (0, 1) - (0, 2) - (0, m) yes    @ R b

? 

b

?  a (1, 1) (1, 2)   b

? 

b

a

b

?  a (2, 1) (2, 2)      

b

b



?  - (1, m) a   no @ R b

a

?  - (2, m) a   no R b @    

Fig. 1. The self-verifying finite automaton An

464

G. Jir´ askov´ a and G. Pighizzini

We claim that An is self-verifying. To prove this, and also for the subsequent discussion, it is useful to consider the following family Q of subsets of Q: Q = {{(x1 , 1), . . . , (xm , m)} | x1 , . . . , xm ∈ {0, 1, 2}}. Note that in Figure 1, the states other than q0 are represented by a grid, according to the two components in their names. Each set belonging to Q corresponds to the choice of one element in each column of such a grid. Notice that after applying a transition by the same letter to all the states in a set belonging to Q , we reach a set of states which still belongs to Q . Extending this argument to strings we get the following remark. Remark 1. For each α ∈ Q and each w ∈ Σ ∗ , the set δ(α, w) belongs to Q . Furthermore, from the initial state (accepting the empty string), by reading a or b, we reach the set {(0, 1), . . . , (0, m)} belonging to Q . Hence, for each x ∈ Σ + , the set δ(q0 , x) contains exactly one of the final states (0, m), (1, m), (2, m). Thus, for each string, the automaton reaches a final state, and it cannot give two different answers on the same string. This permits us of concluding that An is self-verifying. We now closely study the properties of the computations of the svfa An . As a consequence of the previous discussion and of Remark 1, it turns out that in the subset automaton associated with An , all states that can be reached besides the initial state {q0 } belong to Q . We will show that all the elements of Q are reachable. In the following, an element {(x1 , 1), . . . , (xm , m)} belonging to Q will be dem noted simply as the vector (x1 , . . . , xm ) in {0, 1, 2} . With a small abuse of notam tion, for (x1 , . . . , xm ) and (y1 , . . . , ym ) in {0, 1, 2} , we will write (y1 , . . . , ym ) = δ((x1 , . . . , xm ), w), if by reading the string w ∈ Σ ∗ from the state set corresponding to the vector (x1 , . . . , xm ), the state set corresponding to the vector (y1 , . . . , ym ) is reached. m Hence, for each (x1 , . . . , xm ) in {0, 1, 2} , the following holds: • δ((x1 , . . . , xm ), a) = (0, x1 , . . . , xm−1 ), • δ((x1 , . . . , xm ), b) = ((x1 + 1) mod 3, . . . , (xm + 1) mod 3). From the first equality, we can see that the string am can be used to “reset” the “grid part” of the automaton, that is, δ((x1 , . . . , xm ), am ) = (0, . . . , 0) for m each (x1 , . . . , xm ) in {0, 1, 2} . Hence, the state (0, . . . , 0) is reachable from each  state belonging to Q . We now prove the converse. m

Lemma 3. For each (z1 , . . . , zm ) in {0, 1, 2} , the state set corresponding to the vector (z1 , . . . , zm ) is reachable. Proof. Notice that (z1 , . . . , zm ) = δ((0, z2 − z1 , . . . , zm − z1 ), bz1 ), where subtraction is modulo 3. So, it is enough to prove that all states corresponding to vectors (0, y1 , . . . , ym−1 ) with yi in {0, 1, 2} are reachable.

Converting Self-verifying Automata into Deterministic Automata

465

Let y = y1 · · · yk be a string over {0, 1, 2} of length k, 0  k  m − 1, and let us show by induction on k that for each x in {0, 1, 2}, the state corresponding to the vector (0, y1 , . . . , yk , x, x, . . . , x) is reachable. The basis, k = 0, holds true since for each x, state (0, x, x, . . . , x) can be reached from state (0, . . . , 0) by bx a. For the induction step, let y = y1 · · · yk be any string of length k. Then state (0, y2 − y1 , . . . , yk − y1 , x − y1 , . . . , x − y1 ), with subtraction modulo 3, is reachable by induction hypothesis, and it goes to state (0, y1 , . . . , yk , x, . . . , x) by the string by1 a. Hence state

(0, y1 , . . . , yk , x, . . . , x) is reachable, which completes our proof. As a consequence of Remark 1 and Lemma 3, it turns out that in the subset automaton Asub associated with the svfa An , the set of reachable states coincides n−1 with {q0 } ∪ Q . Hence, its cardinality is 1 + 3m = 1 + 3 3 . Now we prove that the automaton Asub is minimal. To this aim, given two different states x = (x1 , . . . , xm ) and y = (y1 , . . . , ym ) in Q , we consider an index j, 1  j  m, such that xj = yj . We remind that xj , yj ∈ {0, 1, 2}. The states (0, j), (1, j) of the svfa An are not compatible because, for instance, the string am−j is accepted by a computation starting from (0, j), but rejected by a computation starting from (1, j). The same string can be used to show that even the states (0, j) and (2, j) are not compatible, while the string am−j b can be used to prove that the states (1, j) and (2, j) are not compatible. Hence, in all possible cases we conclude that there exists a string z witnessing the fact that the states (xj , j) and (yj , j) of An are not compatible. By the standard properties of subset automata, it follows that the same string z distinguishes x and y. Since the initial state {q0 } of the subset automaton is accepting, it cannot be equivalent to any subset of Q that contains either state (1, m) or state (2, m). A subset of Q that contains state (0, m) is distinguishable with {q0 } by the string b. Hence, we get the following result. Lemma 4. The minimal dfa equivalent to the given n-state svfa An is the subset n−1 automaton Asub associated with An and it has 1 + 3 3 states. Now we consider the other values of n. For n = 3m + 2, m  2, we modify the definition of An , by introducing the extra state (3, 1). Furthermore, δ((2, 1), b) = {(3, 1)}, δ((3, 1), b) = {(0, 1)}, and δ((3, 1), a) = δ((2, 1), a) = {(2, 2)}. The other transitions are unchanged. With respect to the automaton depicted in Figure 1, the modified An has one extra state in the first column. This new state is inserted in the loop joining, by transitions labeled with the letter b, the states of the first column, i.e., such a loop has length 4. Furthermore, the only transition from the new state on the letter a reaches the last state of the second column. After this change, all the states in the first column are still not compatible with each other. Along the same lines of the previous proof, in particular of Remark 1 and Lemma 3, it can be proved that the set of reachable states in the subset automaton obtained from An corresponds to {q0 } plus (an isomorphic copy of) m−1 . All these states are pairwise distinguishable. the set {0, 1, 2, 3} × {0, 1, 2} Hence the minimal dfa equivalent to An has 1 + 4 · 3m−1 states.

466

G. Jir´ askov´ a and G. Pighizzini

For n = 3m, m  2, the original definition of An is changed, by removing the state (2, 1) and the outgoing transitions. Furthermore, a transition on the letter b from (1, 1) to (0, 1) is added. Hence the loop on letters b in the first column is of length 2. In this case, we prove that the set of states of the minimal m−1 . dfa equivalent to the given svfa is isomorphic to {q0 } ∪ {0, 1} × {0, 1, 2} We have to modify the proof of reachability in Lemma 3. The basis holds true since (0, . . . , 0) goes to (0, 1, 1, . . . , 1) by ba, and to (0, 2, 2, . . . , 2) by bb. The induction step is the same as in Lemma 3, if y1 = 0 or y1 = 1. In the case of y1 = 2, state (0, 2, y2 , . . . , yk , x, . . . , x) can be reached by the string ab2 from state (0, y2 − 2, . . . , yk − 2, x − 2, . . . , x − 2), which is reachable by induction. Hence the number of states is 1 + 2 · 3m−1 . With the above considered cases, we get the optimality for each n  6. We can also prove, using the same examples, the optimality for n ∈ {3, 4, 5}. In particular, for these values of n, we get that n = 1 + f (n − 1) and the svfa An coincides with the minimal dfa. Finally, we consider n = 1 and n = 2. All the transitions in an svfa with only one state must be self-loops. Hence the svfa is already a dfa accepting or rejecting all Σ ∗ . On the other hand, if an svfa has two states and both are accepting or both are rejecting, then they can be merged, obtaining a one-state svfa (previous case). Hence the only remaining case is that of an svfa consisting of one accepting and one rejecting state. We observe that a nondeterministic choice in such an automaton should imply both the acceptance and the rejection of the same string. Hence, also in this special case the svfa coincides with the minimal dfa. By summarizing we have proved the following result. Theorem 4. For each integer n  1 and each n-state self-verifying finite automaton, there exists an equivalent deterministic finite automaton with g(n) states, where ⎧ n−1 if n ≡ 1 (mod 3) and n  4, 1+3 3 , ⎪ ⎪ ⎨ n−2 3 −1 , if n ≡ 2 (mod 3) and n  5, 1 + 4 · 3 g(n) = n 3 −1 , ⎪ if n ≡ 0 (mod 3) and n  3, ⎪ ⎩1 + 2 · 3 n, if n  2. Furthermore, for each integer n  1, there exists a binary n-state svfa An such that the minimal dfa equivalent to An has exactly g(n) states.

5

Conclusions

We conclude the paper with some considerations concerning our main result. Theorem 4 gives a tight bound on the number of states of a dfa equivalent to a given n-state svfa. The optimality of this bound has been proved by considering a family of automata with a two-letter input alphabet. Hence, one can immediately ask whether or not the optimality holds in the case of unary automata, namely automata with a one-letter alphabet.

Converting Self-verifying Automata into Deterministic Automata

467

It is not difficult to give a negative answer to this question. In fact, as proved by Chrobak [11], the cost, in term of the number of states, of the optimal transformation of nfa’s into dfa’s is given by a function F (n), such that √ F (n) = eΘ( n log n) . Since this function grows slowly than the bound g(n) given in Theorem 4 and svfa’s are special nfa’s, it turns out that F (n) is a better upper bound for the conversion of unary n-state svfa’s into dfa’s. Hence, the next natural question is whether or not this upper bound F (n) is tight. Even in this case, the answer is negative. We can prove this by contradiction. Suppose that a language L is accepted by an n-state svfa A and the minimal dfa accepting L has F (n) states. By Theorem 1, both L and Lc are accepted by n-state nfa’s. However, in [12] it was proved that if a unary language L is accepted by an n-state nfa and the minimal dfa accepting L has F (n) states, that is, the language L is a worst case for the determinization, then each nfa accepting Lc should have at least F (n) states, which implies that the nondeterminism is useless in order to recognize Lc . This gives a contradiction. Hence, we have proved the following theorem. Theorem 5. For each unary n-state self-verifying finite automaton, there exists an equivalent deterministic finite automaton with less than F (n) states. We can increase the nondeterministic capabilities of svfa’s by adding the possibility of multiple initial states. In this case, at the beginning of the computation, the starting state is chosen from a set of possible initial states. The same requirements apply to this kind of automata, namely for each string, the automaton should have a computation reaching an accepting or a rejecting state, and the automaton cannot give two different answers. By the arguments in Section 3, we can prove that each n-state svfa with multiple initial states can be simulated by a dfa whose number of states is given by the function f (n) = g(n + 1) − 1. We can prove that this bound is optimal, by making just a small change to the automata An considered in Section 4. For each integer n  1, we define an automaton Bn by removing from An+1 the initial state q0 and by considering the set {(0, 1), (0, 2), . . . , (0, m)} of possible initial states. By our results in Section 4, it turns out that the minimal dfa equivalent to the svfa Bn must have f (n) states. We also notice that the transition diagram of the svfa Bn is deterministic. The only nondeterministic step is at the beginning of the computation for choosing the initial state. Hence, we actually proved that the tight cost of the simulation of n-state multiple initial state svfa’s by dfa’s is f (n), even if the only nondeterministic step is at the beginning of the computation and all the transitions of the automaton are deterministic. A similar phenomenon happens for deterministic automata with multiple initial state. In [13] it has been proved that for each integer n, there exists a language accepted by an n-state deterministic automaton with multiple initial states such that the minimal equivalent dfa has 2n − 1 states.

468

G. Jir´ askov´ a and G. Pighizzini

Acknowledgments We would like to thank the anonymous referees of LATA 2009 for their valuable comments and suggestions that help us to improve the presentation of our results.

References 1. Goldstine, J., Kappes, M., Kintala, C.M.R., Leung, H., Malcher, A., Wotschke, D.: Descriptional complexity of machines with limited resources. J. UCS 8(2), 193–234 (2002) 2. Rabin, M., Scott, D.: Finite automata and their decision problems. IBM J. Res. Develop. 3, 114–125 (1959) 3. Lupanov, O.: A comparison of two types of finite automata. Problemy Kibernet 6, ¨ 321–326 (1963) (in Russian); German translation: Uber den Vergleich zweier Typen endlicher Quellen, Probleme der Kybernetik 6, 329–335 (1966) 4. Moore, F.: On the bounds for state-set size in the proofs of equivalence between deterministic, nondeterministic, and two-way finite automata. IEEE Transactions on Computers C-20(10), 1211–1214 (1971) 5. Meyer, A.R., Fischer, M.J.: Economy of description by automata, grammars, and formal systems. In: Proc. 12th Ann. IEEE Symp. on Switching and Automata Theory, pp. 188–191 (1971) ˇ s, P., Hromkoviˇc, J., Rolim, J., Schnitger, G.: Las Vegas versus determinism 6. Duriˇ for one-way communication complexity, finite automata, and polynomial-time computations. In: Reischuk, R., Morvan, M. (eds.) STACS 1997. LNCS, vol. 1200, pp. 117–128. Springer, Heidelberg (1997) 7. Hromkoviˇc, J., Schnitger, G.: Nondeterministic communication with a limited number of advice bits. SIAM J. Comput. 33(1), 43–68 (2003) 8. Hromkoviˇc, J., Schnitger, G.: On the power of Las Vegas for one-way communication complexity, OBDDs, and finite automata. Information and Computation 169(2), 284–296 (2001) 9. Assent, I., Seibert, S.: An upper bound for transforming self-verifying automata into deterministic ones. Theoretical Informatics and Applications 41(3), 261–265 (2007) 10. Moon, J., Moser, L.: On cliques in graphs. Israel J. Math. 3, 23–28 (1965) 11. Chrobak, M.: Finite automata and unary languages. Theoretical Computer Science 47, 149–158 (1986); Corrigendum. ibid 302, 497–498 (2003) 12. Mera, F., Pighizzini, G.: Complementing unary nondeterministic automata. Theoretical Computer Science 330(2), 349–360 (2005) 13. Holzer, M., Salomaa, K., Yu, S.: On the state complexity of k-entry deterministic finite automata. Journal of Automata, Languages and Combinatorics 6(4), 453–466 (2001)

Two Equivalent Regularizations for Tree Adjoining Grammars Anna Kasprzik Informatik FB IV, University of Trier, D-54286 Trier

Abstract. We present and compare two methods of how to make derivation in a Tree Adjoining Grammar a regular process (in the Chomsky hierarchy sense) without loss of expressive power. One regularization method is based on an algebraic operation called Lifting, while the other exploits an additional spatial dimension by transforming the components of a TAG into three-dimensional trees. The regularized grammars generate two kinds of “encoded” trees, from which the intended ones can be reconstructed by a simple decoding function. We can show the equivalence of these two two-step approaches by giving a direct translation between lifted and three-dimensional trees and proving that via this translation it is possible to switch between the encodings without losing the information necessary for the reconstruction of the intended trees. Keywords: Tree Adjoining Grammar, Multi-Dimensional Trees, Lifting, Regularization.

1

Introduction

A Tree Adjoining Grammar (TAG) is a special kind of tree grammar which has been developed by Joshi et al. [1] in connection with studies on the formal treatment of natural languages. Joshi et al. [1] claimed the least class of formal languages containing all natural languages to be situated between the context-free and the context-sensitive languages in the Chomsky Hierarchy, and introduced the notion of mild context-sensitivity. The string language classes associated with TAGs are all situated in the family of mildly context-sensitive language classes, which became an important concept for computational linguistics. As mild context-sensitivity represents a relatively high degree of complexity already, it would be of considerable use if there were a way to simplify derivation without giving up any of the expressive power. One of the simplest modes of derivation is the regular one where only the outermost components of an object (e.g. the last symbol of a string) may be rewritten. Regularizing a formalism has the obvious advantage that it makes the whole range of finite-state methods applicable ([2]), which is of interest for most areas based on formal language theory, e.g. natural language processing or grammatical inference ([3]), especially when more complex objects than strings are involved. As a matter of fact, for TAGs at least two such regularization methods exist, and the presentation and comparison of these two approaches constitute the main part of this work. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 469–480, 2009. c Springer-Verlag Berlin Heidelberg 2009 

470

2

A. Kasprzik

Preliminaries

We presuppose some familiarity with classical formal language theory and trees. The necessary preliminaries can be found for example in [4], [5], and also [6]. Definition 1. A TAG is a 5-tuple Σ, N, I, A, S, where Σ is the (non-ranked) terminal labeling alphabet, N is the (non-ranked) nonterminal labeling alphabet with N ∩ Σ = ∅, S is the start symbol with S ∈ N , I is a finite set of initial trees where the root is labeled with S, and A is a finite set of auxiliary trees. Nonterminals label inner nodes and, in auxiliary trees, exactly one leaf which is referred to as the foot node and must carry the same symbol as the root. All other leaves are labeled by terminals or the empty word ε. New trees can be built by adjunction: A node in a tree is replaced by an auxiliary tree and the subtree formerly rooted at that node is attached to the foot node of the auxiliary tree. A TAG can be enriched by associating a pair of constraints with every node, stating if adjunction is required or not (obligatory adjunction (OA) constraint), and which auxiliary trees may be adjoined at that node (selective adjunction (SA) constraint). These constraints obliterate the roles of nonterminal and terminal symbols and the start symbol, and hence the distinction between initial and auxiliary trees as well. Rogers [7] defines non-strict TAGs: Definition 2. A non-strict TAG is a pair E, I where E is a finite set of elementary trees in which each node is associated with a label from some alphabet, an SA constraint (a subset of E), and an OA constraint (Boolean valued). I ⊆ E is a distinguished non-empty subset. Every elementary tree has a foot node.

S

S¯

β=

α= ε

a

S

d

b

S¯

c

Fig. 1. A TAG generating the (non-context-free) string language {an bn cn dn |n ≥ 0} S¯ S¯ S =⇒ ε

a

S

d

b

S¯

c

a

S¯

d

a

S

d

b

S¯

c

b

S¯

c

=⇒

ε

ε

Fig. 2. A derivation of the word aabbccdd

Two Equivalent Regularizations for Tree Adjoining Grammars

471

Non-strict TAGs are equivalent to TAGs with adjunction constraints. We give an example for a non-strict TAG generating the language {an bn cn dn |n ≥ 0}: Example 1. Let G with G = {α, β}, {α} be a non-strict TAG (over the alphabet {a, b, c, d, S}). The only initial tree α and the only auxiliary tree β are given in Figure 1. Constraints at the inner nodes and the foot node are: OA = 0 and SA = {β} for the ones without a bar, and OA = 0 and SA = ∅ ¯ The bar stands for null adjunction, i.e., no adjuncfor the ones labeled with ‘S’. tion is allowed at these nodes. A derivation of the word aabbccdd is shown in Figure 2.

3

Lifted Trees

The technique of Lifting belongs to the realm of treating formal language classes with algebraical means. For the necessary preliminaries concerning universal algebra (esp. many-sorted algebras) and trees as terms, see [8,9]. Definition 3. Let Σ be a ranked alphabet. The derived (N∗ × N)-indexed alphabet of Σ, denoted by D(Σ), is defined as follows. Let, for each n ≥ 0, Σn = {f  |f ∈ Σn } be a new set of symbols; let for each n and each i, 1 ≤ i ≤ n, πin be a new symbol (the ith projection symbol of sort n); and let, for each n, k ≥ 0, cn,k be a new symbol (the (n, k)th composition symbol). Then – – – –

D(Σ)ε,0 = Σ0 ; for n ≥ 1, D(Σ)ε,n = Σn ∪ {πin |1 ≤ i ≤ n} ; for n, k ≥ 0, D(Σ)nkn ,k = {cn,k } , and D(Σ)w,s = ∅ for w ∈ N∗ , s ∈ N otherwise.

Note that all operators in Σ are treated as constants in D(Σ). Lifting a term over some Σ just means translating it into a corresponding term over D(Σ): Definition 4 ([6]). Let Σ be a ranked alphabet. For k ≥ 0, LIFTΣ k : TΣ (Xk ) −→ k (with TΣ (Xk ) the set of terms over Σ ∪{x1 , . . . , xk }) is defined as follows: TD(Σ) k LIFTΣ k (xi ) = πi  LIFTΣ k (f ) = c0,k (f ) for f ∈ Σ0 Σ Σ  LIFTΣ k (f (t1 , . . . , tn )) = cn,k (f , LIFTk (t1 ), . . . , LIFTk (tn ))

for n ≥ 1, f ∈ Σn and t1 , . . . , tn ∈ T (Σ, Xk ) . Lifting has a very useful side effect: If you note a term as a tree and lift it, all inner nodes become leaves. This obviously makes the operation of replacing those nodes by bigger structures a much “simpler” process – speaking in terms of formal language theory, a regular process. Consequently any context-free tree grammar (CFTG, based on the rewriting of inner nodes) over a signature Σ can be translated into a regular tree grammar (RTG, rewriting of leaves only) over the signature D(Σ) by lifting the trees on the right hand sides of the productions and, since all nonterminals have become constants (i.e., leaf labels), by

472

A. Kasprzik

deleting the variables representing daughters on the left hand sides. The intended trees over the original signature can then be reconstructed using the information contained in the “encoded” trees the RTG generates via the following function: rec(f  ) = f (x1 , . . . , xn ) for f ∈ Σn rec(πin ) = xi rec(c(t, t1 , . . . , tn )) = rec(t)[rec(t1 ), . . . , rec(tn )] . The proof of the following lemma (contained implicitly in [8]) is given in [10]: Lemma 1. Suppose Γ = (Σ, F, S, X, P ) is a CFTG and L(Γ ) the tree language it generates. Then there is a derived regular tree grammar Γ L = (D(Σ), D(F), S  , P L ) such that L(Γ ) is the image of L(Γ L ) under the mapping rec. The individual derivation steps also correspond: Lemma 2. A tree t is derived in Γ L from t in k steps, i.e., t ⇒ t via the L L if and only if there are corresponding productions productions pL 1 , . . . , pk in P p1 , . . . , pk in P such that rec(t ) is derived in Γ from rec(t) via those productions. Morawietz [6] has collected some properties of trees generated by a lifted CFTG over some signature D(Σ): a) All inner nodes are and no leaf is labeled by some composition symbol cn,k , b) any node labeled with a symbol in Σn , n ≥ 1, is on a leftmost branch, and c) for any node p labeled with some projection symbol πin there is a unique node μ which properly dominates p and whose ith sister will eventually evaluate to the value of πin under the mapping rec. Moreover, μ will be the first node properly dominating p on a left branch. We will call lifted trees that fulfil condition c) closed lifted trees. Lifting can be used to regularize TAGs as well. However, since TAGs function a little differently from CFTGs (which is linked to the fact that TAG trees are labeled by non-ranked symbols), this is not possible without some transformation. It has been proven by Fujiyoshi and Kasai [11] that every TAG can be translated into a spine grammar, which is a special kind of CFTG, where in the tree on the right-hand side of every production there exists a path from the root to a variable-labeled leaf and every other variable is the child of a node on that path. See [11] for the exact definition, construction, and proof of weak equivalence to TAGs. Their method can be easily adapted to non-strict TAGs as well. Example 2 shows the result of applying the translation of Fujiyoshi and Kasai [11] to the TAG of Example 1, and its lifted version. Example 2. The new CFTG G = (Σ0 ∪ Σ1 ∪ Σ3 , F0 ∪ F1 ∪ F3 , S  , X, P ) obtained from the TAG G in Example 1 is defined as follows: Σ0 = {ε, a, b, c, d}, Σ1 = {s1 }, Σ3 = {s3 }, X = {x1 , x2 , x3 }, F0 = {S  }, F1 = {S1 }, F3 = {S3 }, and ⎧ ⎫ S  −→ s1 (ε) ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ S  −→ S1 (ε) ⎪ ⎪ ⎪ ⎪ ⎨ ⎬ S1 (x1 ) −→ s3 (a, s3 (b, s1 (x1 ), c), d) P = S1 (x1 ) −→ s3 (a, S3 (b, s1 (x1 ), c), d) ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ S3 (x1 , x2 , x3 ) −→ s3 (a, s3 (b, s3 (x1 , x2 , x3 ), c), d) ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎩ ⎭ S3 (x1 , x2 , x3 ) −→ s3 (a, S3 (b, s3 (x1 , x2 , x3 ), c), d)

Two Equivalent Regularizations for Tree Adjoining Grammars

473

c

s3 a

s3

d

a

s3

d

b

s3

c

b

s1

c

c

ε

s3

a

c

d

c

b

c

c

s3

a

c

d

s3

b

c

c

s3

π1

π2

π3

s1

π1

ε

Fig. 3. Two trees, generated via corresponding rules of G and G

L

In lifted form, this grammar then looks like this: G = (D(Σ), D(F), S  , P L ) with D(Σ)ε,0 = {ε, a , b , c , d }, D(Σ)ε,1 = {s1 }, D(Σ)ε,3 = {s3 , π13 , π23 , π33 }, D(Σ)nkn ,k = {c}, D(F)ε,0 = {S  }, D(F)ε,1 = {S1 }, D(F)ε,3 = {S3 }, and ⎫ ⎧   ⎪ ⎪ ⎪ ⎪ S  −→ c(s1, ε) ⎪ ⎪ ⎪ ⎪ S −→ c(S , ε) ⎪ ⎪ 1 ⎪ ⎪  ⎬ ⎨        S1 −→ c(s3 , a , (s3 , b , c(s1 , π1 ), c ), d ) L P = S1 −→ c(s3 , a , (S3 , b , c(s1 , π1 ), c ), d ) ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ S3 −→ c(s3 , a , (s3 , b , c(s3 , π1 , π2 , π3 ), c ), d ) ⎪ ⎪ ⎪ ⎪ ⎪ ⎭ ⎩  S3 −→ c(s3 , a , (S3 , b , c(s3 , π1 , π2 , π3 ), c ), d ) L

Figure 3 shows two corresponding trees generated by G and G – note how the elementary trees of the original TAG are still distinguishable. In fact we can state the following: In a tree generated by a lifted TAG the elementary trees are represented by the tree parts between one composition symbol on a leftmost branch and the next, and the expanded nodes correspond to the mother nodes of these composition symbols. In order to see this, consider the following observations: a) An adjunction operation in a TAG corresponds to the rewriting of an inner node in the corresponding CFTG, and consequently to the rewriting of a leaf in the corresponding lifted CFTG (see Lemma 2) and b) a composition symbol on a leftmost branch is certain evidence that at this node a production of the lifted CFTG has been applied.1 It follows from this that the parts L

1

This can be explained as follows: Lifting a CFTG comprises lifting all the trees on the right-hand sides of the rules. In such a lifted tree all leftmost daughters of any node are labeled with symbols in Σn (for some n), and never by composition symbols. Consequently, a composition symbol on a leftmost branch indicates that the tree cannot be contained as a whole in the rules of the grammar (i.e., as the right-hand side of a rule starting with ‘S  −→ . . .’) but that some production must have been applied that licenses the rewriting of a leaf by the subtree now rooted at the node in question (which, however, can contain other rewritings itself).

474

A. Kasprzik

separated by composition symbols on leftmost branches must match the elementary components of the original TAG. Foot nodes are represented by nodes whose children except the leftmost are all labeled by projection symbols.

4

Three-Dimensional Trees and Their Yields

In this section we will consider a method based on a generalization by Rogers [12,7] of the concept of trees. Starting from ordinary trees based on twodimensional tree domains Rogers extends the concept both downwards (to strings and points) and upwards and defines labeled multi-dimensional trees: Definition 5. Let d 1 be the class of all dth-order sequences of 1s: 0 1 := {1}, and n+1 1 is the smallest set satisfying (i)  ∈ n+1 1, and (ii) if x1 , . . . , xl  ∈ n+1 1 and y ∈ n 1, then x1 , . . . , xl , y ∈ n+1 1. Let T0 := {∅, {1}} (point domains). A (d+1)-dimensional tree domain is a set of hereditarily prefix closed (d+1)st-order sequences of 1s, i.e., T ∈ Td+1 iff – T ⊆ d+1 1, – ∀s, t ∈ d+1 1 : s · t ∈ T ⇒ s ∈ T, – ∀s ∈ d+1 1 : {w ∈ d 1|s · w ∈ T} ∈ Td . A Σ-labeled Td (d-dimensional tree) is a pair (T, τ ) where T is a d-dimensional tree domain and τ : T −→ Σ is an assignment of labels in the (non-ranked) alphabet Σ to nodes in T . We will denote the class of all Σ-labeled Td as TdΣ . Every d-dimensional tree can be conceived to be built up from d-dimensional local trees, that is, trees of depth at most one in their major dimension. Each of these smaller trees consists of a root and an arbitrarily large (d − 1)-dimensional “child tree” consisting of the root’s children. Composite trees can then be built from local ones by identifying the root of one local tree with a node in the child tree of another (see Figure 4 for an illustration). Rogers [7] also defines automata for multi-dimensional trees based on the notion of local trees. For this paper, the most important concept to adapt to multi-dimensionality is that of the yield of a tree. The yield of a two-dimensional tree is the string formed by its leaf labels. In Rogers’ words, it is a projection of the tree onto the next lower level, i.e., its dimensions are reduced by one. So d-dimensional trees with d ≥ 3 have several yields, one for each dimension that is taken away, down to the one-dimensional string yield. Note that when taking the yield of a tree with d ≥ 3, some thought has to go into the question of how to interweave the child trees of its local components to form a coherent (d − 1)-dimensional tree, since there are often several possibilities. Rogers solves this by a construction quite similar to foot nodes in TAGs. See [7] for the exact definition. Rogers [7] has established a link between three-dimensional trees and TAGs – he has proven the equivalence of T3 recognizing automata and non-strict TAGs:

Two Equivalent Regularizations for Tree Adjoining Grammars

475

Fig. 4. Adjunction in TAG expressed via three-dimensional trees

Theorem 1. A set of Σ-labeled two-dimensional trees is the yield of a recognizable set of Σ-labeled T3 trees iff it is generated by a non-strict TAG. From a certain perspective, trees accepted by a T3 automaton derived from a non-strict TAG can be seen as a special sort of derivation trees for that TAG in which one does not have to resort to tree names as node labels since both the elementary trees in question and the way they are combined can be displayed explicitly in the same object. Their direct yield is the set of the trees generated by that TAG, their one-dimensional yield is the corresponding string language. The representation of a TAG via three-dimensional trees obviously also constitutes a regularization: Trees are now constructed by adding local trees at the frontier of another tree (see Figure 4), which is a regular process, instead of inserting trees at the interior. As stated above, the trees generated by the original TAG can be extracted from the three-dimensional trees via the yield function. We have thus described the second regularization method for TAG. We introduce an a bit more “term-like” representation for three-dimensional trees, which will include the concept of rank (in the second dimension), in order to facilitate the comparison to lifted trees. Let Σ be an arbitrary ranked alphabet. We define the set 3DΣ of three-dimensional trees over Σ: Definition 6. (f, t) ∈ 3DΣ if f ∈ Σ0 (f is the root label) and t ∈ 3D+ Σ (t is the structure formed by the nodes properly dominated by the root in the third dimension). 3D+ Σ is the set of antitrunks (three-dimensional trees without a root): + + – (f, t, t1 , . . . , tn ) ∈ 3D+ Σ if f ∈ Σn , t ∈ 3DΣ and ti ∈ 3DΣ for 0 ≤ i ≤ n (the ti are the daughter antitrunks of f in the second dimension). + – (f, t1 , . . . , tn ) ∈ 3D+ Σ if f ∈ Σn and ti ∈ 3DΣ for 0 ≤ i ≤ n.

In addition, we use a binary feature to indicate if a node is a foot node or not. For example, (f, , 1) for some label f ∈ Σ and t ∈ 3D+ Σ is a foot node, (f, t, t1 , t2 , 0) for t1 , t2 ∈ 3D+ is not, and (f, t, t , t , 1) is not well-formed. 1 2 Σ We postulate the following conditions for foot nodes: a) Foot nodes are leaves in the second and third dimension, b) every contiguous two-dimensional tree in an antitrunk has to contain exactly one foot node, c) leaves in the second dimension are also leaves in the third dimension. 0 We will now define our own yield function ydΣ : 3D+ Σ × N → TΣ 0 where Σ 0 is a ranked alphabet with Σn = Σn ∪ Σ0 for every n ≥ 0 and TΣ 0 is the set of all two-dimensional trees over Σ 0 . Let x1 , . . . , xl be elements of a countable set 0 of variables. Let tv , t1 , . . . , tm ∈ 3D+ Σ . The function grk : Σ0 × N → Σ takes a

476

A. Kasprzik

label of rank 0 and yields another label consisting of the same symbol, but with the rank given in the second argument. ⎧ f (ydΣ (t1 , l), . . . , ydΣ (tm , l)) if f ∈ Σm , m ≥ 0, ⎪ ⎪ ⎪ ⎪ ⎪ t = (f, (t1 , . . . , tm ), 0) ⎪ ⎪ ⎪ ⎨yd (t , m)[(yd (t , l), . . . , yd (t , l)] if f ∈ Σ , m ≥ 1, t = Σ v Σ 1 Σ m m ydΣ (t, l) = ⎪ (f, t , (t v 1 , . . . , tm ), 0) ⎪ ⎪ ⎪ ⎪ ⎪fl (x1 , . . . , xl ) if t = (f, (), 1) and ⎪ ⎪ ⎩ f ∈ Σ0 for fl = grk (f, l) The function has three cases because we have to distinguish between foot nodes and non-foot nodes, and among the latter between nodes that have an extension in the third dimension and nodes that do not. The second argument keeps track of the number of daughters of the roots in the third dimension so that when a foot node is reached the correct number of variables can be attached (which are then substituted by the direct subtrees of the corresponding root). The function yd works on antitrunks. In order to obtain the yield of a T3 tree we first have to apply a function ydpre Σ : 3DΣ → TΣ 0 to detach the root and initialize the second argument: ydpre (t ) = ydΣ (t, 0) for a tree ta = (f, t) with f ∈ Σ and t ∈ 3D+ a Σ. Σ

5

Equivalence

We would like to establish the equivalence of the two regularizations for TAGs presented above, based on either the transformation into a lifted spine grammar or into a T3 automaton. In order to do this, it is important to note several structural similarities between the tree-like objects defined by these devices: Both types of objects still include two kinds of information about the originally intended trees, namely which individual components, i.e., elementary trees they are composed of, and how these are put together, which is precisely the information needed to reconstruct the intended trees from the “encoded” ones. With the T3 method the elementary trees are the child structures of the local trees of the T3 tree, and the points where the local trees are joined together are the nodes that are expanded by these child structures. In a tree generated by a lifted TAG the elementary trees are represented by the tree parts between one composition symbol on a leftmost branch and the next, and the expanded nodes correspond to the mother nodes of these composition symbols (see Section 3). We will give a direct formal translation between lifted and T3 trees that exploits these structural similarities by finding corresponding points and making them match. Let us start by giving the function hli translating lifted into T3 trees. For this, let LD(Σ) be a set of trees over D(Σ) characterized by: D(Σ)ε,n ∈ LD(Σ) . – n≥0

– c(f, t1 , . . . , tn ) ∈ LD(Σ) if f ∈ Σn  and t1 , . . . , tn ∈ LD(Σ) \ {πin |1 ≤ i ≤ n} . – c(f, π1 , . . . , πn ) ∈ LD(Σ) if f ∈ Σn and n ≥ 1 .

Two Equivalent Regularizations for Tree Adjoining Grammars

477

– c(t, t1 , . . . , tn ) ∈ LD(Σ) if n ≥ 1, t, t1 , . . . , tn ∈ LD(Σ) \ {πin |1 ≤ i ≤ n} and t contains projection symbols π1 , . . . , πn that are not dominated by more than one composition symbol on a leftmost branch in t. It is clear that all trees generated by a lifted CFTG derived from a TAG via the algorithm from [11] and all their subtrees are contained in LD(Σ) . We will therefore take LD(Σ) as the domain of hli . The range will be the set 3D+ Σ. Let in the following be tv , t1 . . . , tn , q1 , . . . , qm ∈ LD(Σ) for all n, m ≥ 0, and tv , t1 . . . , tn ∈ / {πi |i ≥ 1}. The function gze : Σn → Σ0 takes a label and n≥0

yields another label consisting of the same symbol, but with rank 0. ⎧ (f, (hli (t1 ), . . . , hli (tn )), 0) if t = c(f, t1 , . . . , tn ) ⎪ ⎪ ⎪ ⎪ ⎪ with f ∈ Σn and n ≥ 0 ⎪ ⎪ ⎪ ⎪ ⎪ ⎨(♦, hli (tv ), (hli (t1 ), . . . , hli (tn )), 0) if t = c(tv , t1 , . . . , tn ), hli (t) = n ≥ 1, tv = c(q1 , . . . , qm ) ⎪ ⎪ ⎪ and m≥1 ⎪ ⎪ ⎪ ⎪ ⎪ if t = c(f0 , π1 , . . . , πn ) (f, (), 1) with f = gze (f0 ) ⎪ ⎪ ⎩ with f0 ∈ Σn and n ≥ 1. Like our yield function from the previous section, this function is subdivided into three cases. Here we distinguish between nodes that have projection symbols as daughters (future foot nodes) and nodes that do not, and among those between nodes whose leftmost daughter is a symbol in Σn and nodes whose leftmost daughter is the root of another complex term (which is translated into an extension in the third dimension). As the function does not depend on the subscripts of the composition symbols (cn,k for some n and k), they are left out. The function hli yields antitrunks. In order to translate the elements of LD(Σ) into T3 trees we have to apply the function pli : LD(Σ) → 3DΣ first with pli (t) = (♦, hli (t)) that attaches a three-dimensional root and then recurs to the actual translation function. The symbol ♦ is a special placeholder for labelling three-dimensional roots, since the lifted trees do not contain the information about the labels they should have, i.e., the ones the nodes have in the original TAG before their expansion. It can have any rank (♦ ∈ Σn for all n ≥ 0). The function h3d : 3D+ into lifted trees. Σ × N → LD(Σ) translates antitrunks  Let tv , t1 , . . . , tm ∈ 3D+ . The function g : Σ × N → Σ 0 rk(ε) n takes a label of Σ n≥0

rank 0 and yields another label consisting of the same symbol, but of type ε, n, where n is fixed by the second argument. ⎧ c (f, h3d (t1 , n), . . . , h3d (tm , n)) if m ≥ 0, f ∈ Σm , ⎪ ⎪ ⎪ m ⎪ ⎪ t = (f, (t1 , . . . , tm ), 0) ⎪ ⎪ ⎪ ⎨c (h (t , m), if m ≥ 1, f ∈ Σm and m 3d v h3d (t, n) = ⎪ t = (f, tv , (t1 , . . . , tm ), 0) h3d (t1 , n), . . . , h3d (tm , n)) ⎪ ⎪ ⎪ ⎪ ⎪ cn (f, π1 , . . . , πn ) if n ≥ 1, f0 ∈ Σ0 ⎪ ⎪ ⎩ with f = grk(ε) (f0 , n) and t = (f0 , (), 1).

478

A. Kasprzik

TAG

lifted spine grammar

LD(Σ)

T3 automaton

3DΣ

TΣ

regularization derivation/licensing decoding translation between encodings

Fig. 5. Equivalence of Lifting and three-dimensional trees as TAG regularizations

The cases for this function are identical to the ones for the yield function. Composition symbols on left branches are translated into extensions in the third dimension, and foot nodes are translated into nodes with the right number of sisters (i.e., the number of daughters of the node that was expanded by the corresponding elementary tree in the original TAG) labeled by projection symbols. Of the composition symbols cn,k only the index n is given (the value of k is not as immediate as the one of n but can be easily inferred from the lifted tree afterwards). The function h3d takes antitrunks as its input. If we want to use h3d to translate a T3 tree ta = (f, t) with f ∈ Σ and t ∈ 3D+ Σ , we first have to apply a function p3d : 3DΣ → LD(Σ) with p3d (ta ) = h3d (t, 0) that detaches the root of ta and initializes the second argument of the translation function. Formally, the equivalence of Lifting and of T3 trees as regularization methods for TAG can be shown by proving that the direct decoding of an “encoded” tree and its translation into the other encoding and the decoding of the result yield exactly the same originally intended tree (see Figure 5 for a diagram of the relevant connections). We therefore state the following theorem – a detailed (very technical) proof can be found in [13]:2 Theorem 2. For all closed lifted trees tl ∈ LD(Σ) generated by the lifted version of some TAG (over the alphabet Σ) and all trees ts ∈ 3DΣ generated by the T3 tree version of the same TAG, – rec(ts ) = ydpre (pli (ts )) , and – ydpre (ts ) = rec(p3d (ts )) . Figure 6 shows two encoded trees and the intended tree, which can be generated by the TAG from Example 1 (see Figure 2). The lifted tree in the lower right 2

We also believe an even stronger equivalence in the sense of a bijection to hold: Let A be the set of trees generated by a lifted spine grammar that is the regularized version of a TAG, and let B be the set accepted by a T3 automaton that has been extracted from the same TAG. Then pli (A) = B and p3d (B) = A, and even, for some tree t1 ∈ A, p3d (pli (t1 )) = t1 as well as pli (p3d (t2 )) = t2 for some tree t2 ∈ B.

Two Equivalent Regularizations for Tree Adjoining Grammars

479

S ♦

S S ε

a

yd a

S

d

a

S

d

b

S

c

b

S

c

ε

S

c a

S

S

S

d

b

S

d

c

b c p3d

pli

c

ε

S3

a

c

d

c

b

c

c

rec

S3

a

c

d

S3

b

c

c

S3

π1

π2

π3

S1

π1

Fig. 6. Two encoded trees and the corresponding intended tree

corner can be generated by the regularized version of that TAG (see Example 2), and in the upper right corner is the matching three-dimensional tree.

6

Conclusion

In this paper, we have presented two regularization methods for TAGs. Regularized TAGs of both kinds define sets of “encoded” trees, which, however, still contain the necessary information to reconstruct the intended trees defined by the original TAG. Both methods operate by transforming the components of a TAG in a way that turns all inner nodes into leaves, thus making it possible to expand these nodes by means of a regular mechanism. Both methods exploit a side effect of the theoretical concepts they are based on – algebraic Lifting and the notion of multi-dimensional trees – since neither was developed with the primary intention of regularizing the grammar formalism TAG. However, the methods described here have even more in common: The two different kinds of objects generated by regularized TAGs exhibit a number of structural similarities, which we exploited in order to show their direct translatability. Objects of both kinds can be seen as a special sort of derivation tree for the originally intended tree, and it is only natural that this should be somehow related to regularization in that derivation trees, which are composed starting from a root and adding every further step of the derivation somewhere at the leaves, are a special sort of regular trees – recall that regularity in general represents a mode of constructing an object where one element after the other is

480

A. Kasprzik

added at the frontier of that object, and not somewhere in between. By letting us find different kinds of derivation trees for a formalism, in addition to gaining knowledge about how the properties of derivation as such can be modified, the study of regularization may thus perhaps give further insight about derivation in the formalism in particular as well. A possible continuation of this work could be to search for more regularization methods for TAGs and determine if the structure of the objects created in the process resembles the structure of the objects treated here. One could even conjecture that every similar effort to reduce the complexity of derivation must result in similar properties, i.e., in objects that are directly translatable into lifted or three-dimensional trees as well.

References 1. Joshi, A.K., Levy, L.S., Takahashi, M.: Tree Adjunct Grammars. Journal of Computer and System Sciences 10(1), 136–163 (1975) 2. Kasprzik, A.: Making Finite-State Methods Applicable to Languages Beyond Context-Freeness via Multi-dimensional Trees. In: Piskorski, J., Watson, B., YliJyr¨ a, A. (eds.) Post-proc. 7th Int. Workshop on Finite-State Methods and NLP. IOS Press, Amsterdam (2009), www.uni-trier.de/index.php?id=18342 3. Kasprzik, A.: A Learning Algorithm for Multi-dimensional Trees, or: Learning beyond Context-Freeness. In: Clark, A., Coste, F., Miclet, L. (eds.) ICGI 2008. LNCS, vol. 5278, pp. 111–124. Springer, Heidelberg (2008), www.uni-trier.de/index.php?id=18342 4. Hopcroft, J.E., Ullman, J.D.: Introduction to automata theory, languages, and computation. Addison-Wesley, Reading (1979) 5. G´ecseg, F., Steinby, M.: Tree automata. Akademiai Kiado (1984) 6. Morawietz, F.: Two-Step Approaches to Natural Language Formalisms. Studies in Generative Grammar, vol. 64. Mouton de Gruyter, Berlin (2003) 7. Rogers, J.: wMSO Theories as Grammar Formalisms. TCS 293, 291–320 (2003) 8. Engelfriet, J., Schmidt, E.: IO and OI (I). J. Comp. & Sys. Sci. 15, 328–353 (1977) 9. Engelfriet, J., Schmidt, E.: IO and OI (II). J. Comp. & Sys. Sci. 16, 67–99 (1978) 10. M¨ onnich, U.: On cloning contextfreeness. In: Kolb, H.P., M¨ onnich, U. (eds.) Studies in Generative Grammar, vol. 44, pp. 195–229. Mouton de Gruyter, Berlin (1999) 11. Fujiyoshi, A., Kasai, T.: Spinal-formed context-free tree grammars. Theory of Computing Systems 33, 59–83 (2000) 12. Rogers, J.: Syntactic Structures as Multi-dimensional Trees. Research on Language and Computation 1, 265–305 (2003) 13. Kasprzik, A.: Two Equivalent Regularizations for Tree Adjoining Grammar. M.A. thesis (2007), http://www.uni-trier.de/index.php?id=18342

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm for Weighted Matching Aude Liefooghe1,2 , H´el`ene Touzet1,2 , and Jean-St´ephane Varr´e1,2 1

LIFL - UMR CNRS 8022 - Universit´e des Sciences et Technologies de Lille, 59655 Villeneuve d’Ascq Cedex, France 2 INRIA Lille Nord-Europe, 59650 Villeneuve d’Ascq, France [email protected]

Abstract. Position Weight Matrices are broadly used probabilistic motif models. In this paper, we address the problem of identifying and characterizing potential overlaps between occurrences of such a motif. It has useful applications to the statistics of the number of occurrences, and to weighted pattern matching with an extension of the well-known Knuth-Morris-Pratt algorithm.

1

Introduction

Position Weight Matrices (PWMs for short) are probabilistic approximate patterns. They are popular in computational biology, because they can depict subtle signals in genomic or peptidic sequences. For example, transcription factor binding sites are commonly modeled by such motifs. PWMs are also used to represent splice sites in messenger RNAs [1] or signatures in amino acid sequences [2]. Given a finite alphabet Σ and a positive integer m, a PWM M is a function from Σ m to IR that associates a score to each word of Σ m . It has one row for each symbol of the alphabet, and one column for each position in the pattern. The coefficient M (p, x) gives the score at position p for the letter x in Σ. Given a string u in Σ m , the score of M on u is defined as the sum of the scores of each character symbol of u: Score(u, M ) =

m−1 

M (p, up ),

p=0

where up denotes the character symbol at position p in u. Let α be a score threshold. We say that M has an occurrence in the text T at position k if Score(Tk . . . Tk+m−1 , M ) ≥ α. In this paper, we investigate the self-overlapping properties of PWMs. The propensity of a motif to have overlapping occurrences in a text has many consequences. It can be used for computing the statistics of the number of occurrences in a random text, since occurrences of a self-overlapping motif are not independent [3,4]. It is also crucial in pattern matching. Among ideas that allow to speed A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 481–492, 2009. c Springer-Verlag Berlin Heidelberg 2009 

482

A. Liefooghe, H. Touzet, and J.-S. Varr´e

up pattern searching, many of them exploits a preprocessing of the pattern that takes advantage of internal overlaps inside the pattern. Famous examples are Knuth-Morris-Pratt [5] and Boyer-Moore [6] algorithms. In the case of multiple exact pattern matching, the same idea gives rise to the Aho-Corasick automaton [7]. The contributions of this paper are the following. In Section 2, we provide a formal characterization of self-overlapping PWMs, as well as an algorithm to efficiently compute the borders of a PWM. In Section 3, we show how to use this result to express the covariance and the variance of the number of occurrences of a PWM in a text. In Section 4, we explain how to adapt the Knuth-Morris-Pratt paradigm to PWMs on the basis of borders for PWMs. This last point gives rise to three pattern matching algorithms, that we have experimentally evaluated on PWMs from the Jaspar database [8].

2

Analysis of Self-overlapping Occurrences of a PWM

We consider throughout a text T of length n on a finite alphabet Σ, and we assume that the character symbols at various positions are independent. Each character symbol x of Σ is assigned a probability μx . We also consider a PWM M of length m on Σ, whose indices range from 0 to m − 1. 2.1

Definitions

The “self-overlapping” property of a word u gives rise to several definitions. The terms may be different in each application field, but the concept is the same. In statistics, this property is usually handled with an indicator function, that is equal to 1 if the first  letters of u are the same, and in the same order as the last  letters of u, and 0 otherwise. In stringology, this property is captured with the notion of border. A border of u of length  is a prefix of length  which is also a suffix of u. We extend this definition to motifs modeled by PWMs. Definition 1 (Matrix border). Let M be a PWM of length m and let α be a score threshold for M . A border for M and α is a word u of Σ  , with  < m, such that there exist v, w ∈ Σ m− satisfying: 1. Score(M, uv) ≥ α, and 2. Score(M, wu) ≥ α. It is easy to see that this definition coincides with the definition of border in the case of exact strings. We introduce an equivalent characterization, that relies on the definition of the maximal score of a matrix, and the greatest lower bound of the score of a given position. Definition 2 (Maximal score). Let M be a PWM of length m, and let M [i..j] be a slice of M (0 ≤ i ≤ j < m). The maximal score of M [i..j], denoted MaxSc(M [i..j]), is j  max M (k, x) MaxSc(M [i..j]) = k=i

x∈Σ

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm

483

Definition 3 (Greatest Lower Bound). Let M be a PWM of length m, α a score threshold, and p a position of M (0 ≤ p < m). The Greatest Lower Bound of M , p and α, denoted, GLB(M, p, α), is defined as GLB(M, p, α) = α − MaxSc(M [p + 1..m − 1]) The greatest lower bound score was originally introduced in [9]. It can be shown that a word u is an occurrence for M and α if, and only if, for each position p of u, Score(M, u0 ..up ) ≥ GLB(M, p, α). Lemma 1. Let M be a PWM of length m, and let α be a score threshold. The word u of length  is a border of M and α if, and only if, u fulfills the two following properties: 1. Score(M [0.. − 1], u) ≥ GLB(M,  − 1, α), and 2. Score(M [m − ..m − 1], u) ≥ α − MaxSc(M [0..m −  − 1]). Proof (⇒) Let u be a border of length . By Definition 1, there exist two words v and w such that Score(M, uv) ≥ α and Score(M, wu) ≥ α. From the first inequality, it follows that Score(M [0.. − 1], u) ≥ α − Score(M [..m − 1], v) and then Score(M [0.. − 1], u) ≥ GLB(M,  − 1, α). From the second inequality, it follows that Score(M [m − ..m − 1], u) ≥ α − Score(M [0..m −  − 1], w) and then Score(M [m − ..m − 1], u) ≥ α − MaxSc(M [0..m −  − 1]). (⇐) Assume that u satisfies statements 1. and 2. of the Lemma. By Definition 3, this implies that there exists a word v such that Score(M, uv) ≥ α, and by Definition 2 that there exists a word w such that Score(M, wu) ≥ α. Subsequently, u is a border of M and α.   Definition 4 (c(M, p, α)). Define the predicate c(M, p, α) as true if, and only if, there exists a border of length m − p for M and α. 2.2

How to Compute c

We introduce b, that will serve as an auxiliary function to compute c. Definition 5. Let M be a PWM of length m, and let p, i be two positions of M (0 ≤ p ≤ i ≤ m − 1). We define the function b as b(M, p, i, β, δ) = ∃u ∈ Σ i−p+1 (Score(M [p..i], u) = β ∧ Score(M [0..i − p], u) = δ) Lemma 2 c(M, p, α) = ∃ β ≥ α − MaxSc(M [0..p − 1]) ∃ δ ≥ GLB(M, m − 1 − p, α) such that b(M, p, m − 1, β, δ) Proof. By Definition 4 and Lemma 1, c(M, p, α) is true if, and only if, there exists a word u of length m − p such that 1. Score(M [0..m − p − 1], u) ≥ GLB(M, m − p − 1, α), and 2. Score(M [p..m − 1], u) ≥ α − MaxSc(M [0..p − 1]

484

A. Liefooghe, H. Touzet, and J.-S. Varr´e

Set β = α − MaxSc(M [0..p − 1]) and δ = GLB(M, m − 1 − p, α). This concludes the proof.   Lemma 2 implies that it is sufficient to be able to compute b to deduce c. We now explain how to compute b efficiently. Lemma 3 ⎧ ⎨ b(M, p, i, 0, 0) = 1, whenever i < p b(M, p, i, β, δ) = 0, whenever i < p, β = 0 or δ = 0 ⎩ b(M, p, i, β, δ) = ∨x∈Σ b(M, p, i − 1, β − M (i, x), δ − M (i − p, x)) otherwise Proof. When i < p, the results comes from the definition of b. For the general case, b(M, p, i, β, δ) is true if, and only if, there exists a letter x of Σ satisfying the following property: there exists v in Σ i−p such that Score(M [p..i − 1], v) = β − M (i, x) and Score(M [0..i − p − 1], v) = δ − M (i − p, x), which is equivalent to b(M, p, i − 1, β − M (i, x), δ − M (i − p, x)). So for each p, b(M, p, i, β, δ) can be computed by lazy dynamic programming from smaller values of i, β and δ. A useful remark is that it is not necessary to consider all possible parameters for the final value of c. This is the goal of the next lemma. Lemma 4. c(M, p, α) is true if, and only if, for each value i ranging from p to m − 1, there exist β and δ, such that 1. b(M, p, i, β, δ) = 1, and 2. β ≥ GLB(M, i, α) − MaxSc(M [0..p − 1]), and 3. δ ≥ GLB(M, i − p, α). Proof (⇒) If c(M, p, α) is true, then we know from Definition 5 and Lemma 2 that there exists a word u of Σ m−p such that Score(M [p..m − 1], u) ≥ α − MaxSc(M [0..p − 1]) Score(M [0..m − 1 − p], u) ≥ GLB(M, m − 1, α) Consider now a position i in p..m − 1. The values β = Score(M [p..i], u0 ..ui−p ) and δ = Score(M [0..i − p], u0 ..ui−p ) fulfills the conditions of the Lemma, by definition of GLB. (⇐) Straightforward.

 

The implementation can use a hashtable to store the set of pairs of scores (β, δ) satisfying the conditions of Lemma 4 for given values of i and p: c(M, p, α) is p true if, and only if, Sm−1 is not empty.

3

Application to Counting Occurrences in a Text

In this section, we are interested in the number of occurrences of a PWM in a text T . We define Y as the random number of occurrences of M and α in T . Our aim is to find the mean and the variance of Y .

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm

3.1

485

Probability of Observing Two Overlapping Occurrences

We first study the probability to observe two overlapping occurrences for M and α. For that purpose, define the indicator variable Yk by Yk = 1 if M occurs in position k in the text T with score greater than α, Yk = 0 if it does not. It is routine to verify that E[Yk ] = Pv(M, α) V [Yk ] = Pv(M, α)(1 − Pv(M, α)) where Pv(M, α) denotes the P-value of the score α for M , that is the probability of the set of words that are recognized by M and α: Pv(M, α) = IP ({u ∈ Σ m ; Score(M, u) ≥ α}) The computation of Pv(M, α) can be performed efficiently by dynamic programming [10,11]. We are interested in the probability of having Yk = 1 and Yk+p = 1, for some 1 ≤ p ≤ m − 1. This event is true if there exist β and δ such that 1. Score(M [0..p − 1], Tk ..Tk+p−1 ) ≥ α − β, 2. Score(M [p..m − 1], Tk+p ..Tk+m−1 ) = β and Score(M [0..m − p − 1], Tk+p ..Tk+m−1 ) = δ, 3. Score(M [m − p..m − 1], Tk+m ..Tk+p+m−1 ) ≥ α − δ. Since positions in the text are independent, this decomposition gives rise to three mutually independent events, whose probabilities are respectively Pv(M [0..p − 1], α − β), B(M, p, m − 1, β, δ) and Pv(M [m − p..m − 1]), α − δ) where: B(M, p, i, β, δ) =  IP u ∈ Σ i−p+1 ; Score(M [p..i], u) = β ∧ Score(M [0..i − p], u) = δ It follows that

IP (Yk = 1, Yk+p = 1) = β,δ Pv(M [0..p − 1], α − β) ×B(M, p, m − 1, β, δ) ×Pv(M [m − p..m − 1]), α − δ) The computation of B is similar to the computation of b. 3.2

Mean, Covariance and Variance

Lemma 5. E[Y ] = (n − m + 1)Pv(M, α).

Lemma 6. Cov[Yk , Yk+p ] = β,δ Pv(M [0..p − 1], α − β) × B(M, p, m − 1, β, δ) × Pv(M [m − p..m − 1]), α − δ) − Pv(M, α)2 Proof. By definition of the covariance, we have Cov[Yk , Yk+p ] = E[Yk , Yk+p ] − E[Yk ]E[Yk+p ] Since Yk and Yk+p are indicator functions, E[Yk , Yk+p ] equals IP (Yk = 1, Yk+p = 1), which has been calculated in the preceding paragraph. E[Yk ] and E[Yk+p ] both equal Pv(M, α).  

486

A. Liefooghe, H. Touzet, and J.-S. Varr´e

Lemma

7. V [Y ] = Pv(M, α)((n − m + 1)(1 − Pv(M, α)) − Pv(M, α)) +2 β,δ Pv(M [0..p−1], α−β)×B(M, p, m−1, β, δ)×Pv(M [m−p..m−1]), α−δ) Proof. By property of a variance, we have V [Y ] =

n−m  k=0

V [Yk ] +

n−m  n−m 

Cov[Yk , Yj ]

k=0 j=0

n−m n−m In the sum k=0 j=0 Cov[Yk , Yj ], we only have to consider positions k and j such that k − m < j < k + m. Other covariances equal 0. Applying Lemma 6 yields the expected result.  

4 4.1

Application to Text Searching and the Knuth-Morris-Pratt Algorithm Previous Work Related to PWM Pattern Matching

The problem of efficiently finding occurrences of a PWM in a text has recently attracted a lot of interest. Wu et al. were the first ones to propose an improvement of the naive algorithm with the lookahead strategy [9]. They used the fact that one can determine in advance whether a prefix of a word may potentially lead to an occurrence or not, using the greatest lower bound of Definition 3. In [12], Liefooghe et al. combined this lookahead strategy with the additivity property of the scoring function to implement a solution based on a multi-table index. This index pre-compute scores for slices of the given matrices and stores them in an optimized way. Other authors proposed to adapt methods that were initially designed for exact string matching and that are proven to be efficient in this context. The first possibility is to preprocess the text. Beckstette et al. proposed in [13] to build a suffix array and took advantage of the lookahead strategy to improve the size of the index. Pizzi et al.[14] introduced a filtration technique that is based onto a preprocessing of the text for which the computation of the occurrences of an automaton that contains at least all occurrences of the matrix are computed. Lastly, Salmela et al. proposed an expansion of the well-known Shift-Add algorithm to PWMs [15]. The principle of Shift-Add approaches is to use bitwise computation during the searching phase. The complexity of the algorithm depends on the score threshold and the rounding of the scores of the matrix. Another idea is to preprocess the pattern in order to maximise the length of the shift of the pattern after a mismatch occurs during the scan of the text. This is implemented in the Morris-Pratt and Knuth-Morris-Pratt algorithms for exact string matching. The method computes a table that gives the next position of the text that has to be tested when an attempt fails. The searching phase consists in jumping from a current position to the next position using the value stored in the table. In [14], Pizzi et al. studied the construction of the AhoCorasick automaton [7] for PWMs, which is a generalization of Knuth-MorrisPratt for multi-pattern matching. It appears that the Aho-Corasick automaton

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm

487

is very large if the PWM is long or if the score threshold is low. In practice, this method is not suitable for matrices of length greater than fifteen. The advantage of Morris-Pratt and Knuth-Morris-Pratt tables is that their size equals the length of the motif. We recall the way the algorithm works on exact string motifs and we then extend it to PWMs. 4.2

The Original Morris-Pratt and Knuth-Morris-Pratt Algorithms

The Morris-Pratt and Knuth-Morris-Pratt algorithms search for occurrences of a word u within a text T by employing the observation that when a mismatch occurs, the word itself embodies some information to determine where the next match could begin. This information is used to improve the length of the shift of the pattern against the text. Morris-Pratt Algorithm. The shift of the Morris-Pratt algorithm is based on the longest border. Let mpNext[i] be the length of the longest border of u0 ..ui−1 for 0 < i ≤ m. When an attempt fails at position i in the pattern and j in the text, then the comparison can resume between characters i − mpNext[i] in u and j in T without missing any occurrence. Knuth-Morris-Pratt Algorithm. The additional idea of the Knuth-Morris-Pratt algorithm is that if we want to avoid another immediate mismatch, the character following the prefix in the pattern must be different from the current symbol. For that, the shift rule uses tagged borders, instead of borders. Given a border v of length  of the prefix u0 . . . up−1 of length of u, v is a tagged border if the character symbol up is different from u . kmpNext[i] is the length of the longest tagged border of u0 ..ui−1 . 4.3

Expansion to Position Weight Matrices

In the context of exact string matching, a failure comes from a mismatch between the motif and the text. An attempt at position k in the text stops at position i if Tk ..Tk+i−1 = u0 ..ui−1 and Tk+i = ui . When the motif is a PWM, this rule depends on the score of the prefix of the motif. An attempt stops as soon as the running score is too low: Score(M [0..i], Tk ..Tk+i ) < GLB(M, i, α). By Definition 3, we know that there is no occurrence of M and α starting at position k in the text. We now explain how to construct the mpNext and kmpNext tables. Morris-Pratt Algorithm. The extension to PWMs is straightforward. We denote Border(M, α) the length of the longest border of M and α, according to Definition 1. mpNext is a vector of size m + 1 whose elements are defined as follows: mpNext[0] = −1 mpNext[i] = Border(M [0..i − 1], GLB(M, i − 1, α)), 1 ≤ i ≤ m The computation of each element of mpNext is done using Definition 4: mpNext[i] equals i−p, where p is the lowest value such that c(M [0..i−1], p, GLB(M, i−1, α)) is true. All necessary values of c(M [0..i − 1], p, GLB(M, i − 1, α)) can be efficiently computed using Lemma 4.

488

A. Liefooghe, H. Touzet, and J.-S. Varr´e

Knuth-Morris-Pratt Algorithm. We first need to extend the notion of tagged border to position weight matrices. Definition 6. Let M be a PWM, i a position of M and α a score threshold. u is a tagged border for M , i and α, if u is a border of M [0..i] and GLB(M, i, α), and there exists a letter x of Σ such that 1. Score(M [0..], ux) ≥ GLB(M, , α), and 2. Score(M [i − ..i], ux) < GLB(M, i, α) − MaxSc(M [0..i −  − 1]). where  is the length of u. We write TaggedBorder(M, i, α) for the length of the longest tagged border of M , i and α. By convention, TaggedBorder(M, i, α) equals -1 if a suitable u does not exist. We now define the table kmpNext as follows: kmpNext[0] = −1 kmpNext[i] = TaggedBorder(M, i − 1, α), 1 ≤ i ≤ m We introduce a new predicate to compute kmpNext. Definition 7 (c (M, p, i, α)). Define the predicate c (M, p, i, α) as true if, and only if, there exists a tagged border of length i − p for M , i − 1 and α. kmpNext[i] equals i − p, where p is the lowest value such that c (M, p, i − 1, α) is true. The effective computation of c is done with the next lemma, that shows that c can be deduced from b. Lemma 8. c (M, j, i, α) is true if, and only if, there exist two scores β, δ and a letter x of Σ such that 1. b(M, j, i − 1, β, δ) = 1, and 2. GLB(M, i − 1, α) − MaxSc(M [0..j − 1]) ≤ β < GLB(M, i, α) − MaxSc(M [0..j − 1]) − M (i, x), and 3. δ ≥ GLB(M, i − j, α) − M (i − j, x). 4.4

The kmpNextΣ Table

We propose here a variation of the Knuth-Morris-Pratt algorithm, that implements a shift which depends on the failure letter. Instead of computing the longest tagged border, we compute for each letter x of Σ the longest border which is not followed by x. We will see in Section 4.6 that it gives rise to better shifts and then to a better running time. Definition 8 (x-tagged border). Let M be a PWM, i a position of M , α a score threshold and x a letter of Σ. u is a x-tagged border for M , i, and α, if u is a border of M [0..i] and GLB(M, i, α) such that 1. Score(M [0..], ux) ≥ GLB(M, , α), and 2. Score(M [i − ..i], ux) < GLB(M, i, α) − MaxSc(M [0..i −  − 1]), where  is the length of u.

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm

489

We write Σ-TaggedBorder(M, i, α, x) the length of the longest x-tagged border of M , i, and α. The shift rule associated to x-tagged borders is specified by a two-entry table: one for the position, and one for the current character symbol. The table kmpNextΣ is defined as follows: kmpNextΣ [0][x] = −1 kmpNextΣ [i][x] = Σ-TaggedBorder(M, i, α, x),

1≤i≤m

Lemma 9. kmpNext[i] = minx∈Σ kmpNextΣ [i][x] Proof. kmpNextΣ [i][x] gives the length of the longest border u which fulfills the two conditions of Definition 8. Hence,  = minx∈Σ kmpNextΣ [i][x] implies that there exists a border u of length  and there exists a letter y in Σ such that the two conditions of Definition 8 are fulfilled. This is exactly the definition of kmpNext[i].   As we have done previously, we define a predicate that tells whether a x- tagged border exists or not. The difference compared to c is that the letter x is a parameter of the predicate. Definition 9 (c (M, p, i, α, x)). Define the predicate c (M, p, i, α, x) as true if, and only if, there exists a fixed letter tagged border of length i − p for M , i − 1, α and x. kmpNextΣ [i][x] equals i − p, where p is the lowest value such that c (M, p, i − 1, α, x) is true. Lemma 10. c (M, p, i, α, x) is true if, and only if, there exist two scores β, δ such that 1. b(M, j, i − 1, β, δ) = 1, and 2. GLB(M, i − 1, α) − MaxSc(M [0..j − 1]) ≤ β < GLB(M, i, α) − MaxSc(M [0..j − 1]) − M (i, x), and 3. δ ≥ GLB(M, i − j, α) − M (i − j, x). 4.5

Looking for Occurrences Using mpNext, kmpNext or kmpNextΣ

We now give the proof that the shifts induced by the mpNext, kmpNext or kmpNextΣ tables are safe: they do not allow to miss occurrences in the text. Lemma 11. Let M a PWM, α be a score threshold, T be a text, k be a position of T and i be a position of M . If the attempt k fails at position i of M , we know there is no occurrence for M and α for any position k + j of T such that 1 ≤ j ≤ i − mpNext[i], or 1 ≤ j ≤ i − kmpNext[i], or 1 ≤ j ≤ i − kmpNextΣ [i][T [k + i]]. Proof. We give the proof for mpNext. The two other cases are similar. Suppose that there exists a position k+j, 1 ≤ j ≤ i−mpNext[i] such that Tk+j ..Tk+j+m−1 is an occurrence. Then Score(M, Tk+j ..Tk+j+m−1 ) ≥ α and thus Score(M [0..i− j], Tk+j ..Tk+i−j ) ≥ GLB(M, i − j, α). But necessarily Score(M [j − 1..i − 1],

490

A. Liefooghe, H. Touzet, and J.-S. Varr´e

Tk+j ..Tk+i−j ) < α − MaxSc(M [0..j − 2]). Otherwise Tk+j ..Tk+i−j would be a border of length i − j + 1 of M [0..i − 1], which is impossible because mpNext[i] < i − j + 1. This second inequality contradicts the fact that an attempt fails at position i of M .   Contrarily to the original Knuth-Morris-Pratt searching phase, we cannot avoid to re-compute the score of the prefix against the text when shifting. This leads to a time complexity in O(mn) in the worst case, instead of O(m + n) for exact pattern matching. Nevertheless, there is still a strict improvement compared to the lookahead strategy algorithm. 4.6

Experimental Results

As mentioned in the introduction of this paper, PWMs are commonly used to model transcription factor binding sites. We measured the impact of the shifting rules on the Jaspar database [8]. Jaspar contains 123 PWMs that are derived from experimentally validated binding sites. The length of the PWMs ranges from 4 to 30. We computed the occurrences of each matrix from a random DNA sequence of 50 megabases. We used several P-values to define several score thresholds (see Section 3.1). Only matrices whose length allows to have at least one occurrence, 4m × p ≥ 1, for a given P-value p are used for each experiment in order to not artficially reduce the average running time. We compared the running times of the naive algorithm (NA), the lookahead stategy algorithm (LSA), the expansions of the Knuth-Morris-Pratt algorithm using the kmpNext table (KMP) and the kmpNextΣ table (KMB-AB). The algorithms have been implemented in C++ and a computer with a 2.33GHz Intel Core 2 Duo processor with 2 gigabytes of main memory has been used. Table 1 gives the average searching phase running time for the four algorithms and the average preprocessing running time for KMP and KMP-AB. Figure 1 gives the total running time per matrix for P-value 10−4 . Algorithm KMP-AB achieves the best running time, outperforming the algorithm using the lookahead strategy. As we could expect, the running time increases when the P-value increases (the score threshold decreases) because the shifts become smaller. If one removes the longest matrix (of length 30) from the experiments, the preprocessing running time is almost the same for computing the kmpNext table or the Table 1. Average running times of the searching and preprocessing phases per matrix (in seconds) for several P-values p = 10−7 p-value nb. of matrices 45 NA 3.80 1.41 Searching LSA 0.95 phase KMP 0.71 KMP-AB Preprocessing KMP 0.019 0.956 phase KMP-AB

p = 10−5 86 3.22 1.86 1.13 0.86 0.023 0.513

p = 10−3 122 2.81 2.62 1.35 1.34 0.043 0.418

Self-overlapping Occurrences and Knuth-Morris-Pratt Algorithm

7

NA LSA KMP KMP-AB

6 Time (in seconds)

491

5 4 3 2 1

22 30

20

17 18

16

15

13 14

12

11

10

9

0 Matrices (grouped by length)

Fig. 1. Running times per matrix (in seconds) for P-value 10−5 Table 2. Average searching plus preprocessing running times per matrix (in seconds) with the filtration technique KMP KMP-AB

p = 10−7 0.48 0.54

p = 10−5 0.63 0.65

p = 10−3 0.79 0.82

kmpNextΣ table. Without this matrix, the average preprocessing running time for computing kmpNextΣ tables becomes respectively 0.009s, 0.014s and 0.062s for P-values 10−7 , 10−5 and 10−3 . The preprocessing running time increases with the P-value and the length of the matrices. The sum of the preprocessing and searching phase running times is almost always less than the LSA running time. Moreover, as the patterns used for finding transcription factor binding sites are permanent objects stored into databases, the computation need to be done only once. When the shift computed thanks to the next tables equals 1, KMP and KMPAB do not increase the efficiency of the searching phase. Let r be the rightmost position of a matrix such that all shifts between 0 and r equal 1. Instead of computing iteratively the score from 0 to r, we can directly compute the score of the prefix of length r + 1. This can be done thanks to a preprocessing phase which computes the scores for all words of length r + 1 and stores them into a table [12]. If r is not too large, the running time and the amount of memory used are small. Table 2 gives the average running time when we applied this refinement with r limited to 7 (preprocessing running time is less than 0.01s). KMP is the fastest algorithm, with a gain of almost 50% compared to KMP without filtration. KMP gives better results compared to KMP-AB because the value of r is lower with KMP-AB.

5

Conclusion

We extended the definition of a border for PWMs. This allowed to devise two algorithms directly derived from the Morris-Pratt and Knuth-Morris-Pratt algorithms and a new algorithm (KMP-AB). We then proposed to use a refinement

492

A. Liefooghe, H. Touzet, and J.-S. Varr´e

which, at the cost of a little amount of memory and preprocessing time, allows to get the best of the shifts and leads to a speed-up of almost three in practice compared to the LSA algorithm.

References 1. Mount, S.: A catalogue of splice junction sequences. Nucleic Acids Research 10, 459–472 (1982) 2. Hulo, N., Sigrist, C., Saux, V.L., Langendijk-Genevaux, P., Bordoli1, L., Gattiker, A., Castro, E.D., Bucher, P., Bairoch, A.: Recent improvements to the PROSITE database. Nucleic Acids Research 32, D134–D137 (2004) 3. Ewens, W., Grant, G.: Statistical Methods in Bioinformatics. Springer, Heidelberg (2005) 4. Pape, U., Rahmann, S., Sun, F., Vingron, M.: Compound poisson approximation of the number of occurrences of a position frequency matrix (PFM) on both strands. Journal of Computation Biology 15, 547–564 (2008) 5. Knuth, D., Morris Jr., J., Pratt, V.: Fast pattern matching in strings. SIAM Journal on Computing (1977) 6. Boyer, R.S., Moore, J.S.: A fast string searching algorithm. Commun. ACM 20, 762–772 (1977) 7. Aho, A., Corasick, M.: Efficient string matching: an aid to bibliographic search. Communications of the ACM (1975) 8. Sandelin, A., Alkema, W., Engstr¨ om, P., Wasserman, W.: Jaspar: an open-access database for eukaryotic transcription factor binding profiles. Nucleic Acids Research (2004) 9. Wu, T.D., Nevill-Manning, C.G., Brutlag, D.L.: Fast probabilistic analysis of sequence function using scoring matrices. Bioinformatics 16, 233–244 (2000) 10. Staden, R.: Methods for calculating the probabilities of finding patterns in sequences. Comput. Appl. Biosci. 5, 89–96 (1989) 11. Touzet, H., Varr´e, J.S.: Efficient and accurate p-value computation for position weight matrices. Algorithms for Molecular Biology 2 (2007) 12. Liefooghe, A., Touzet, H., Varr´e, J.S.: Large scale matching for position weight matrices. In: Lewenstein, M., Valiente, G. (eds.) CPM 2006. LNCS, vol. 4009, pp. 401–412. Springer, Heidelberg (2006) 13. Beckstette, M., Homann, R., Giegerich, R., Kurtz, S.: Fast index based algorithms and software for matching position specific scoring matrices. BMC Bioinformatics (2006) 14. Pizzi, C., Rastas, P., Ukkonen, E.: Fast search algorithms for position specific scoring matrices. In: Hochreiter, S., Wagner, R. (eds.) BIRD 2007. LNCS (LNBI), vol. 4414, pp. 239–250. Springer, Heidelberg (2007) 15. Salmela, L., Tarhio, J.: Algorithms for weighted matching. In: Ziviani, N., BaezaYates, R. (eds.) SPIRE 2007. LNCS, vol. 4726, pp. 276–286. Springer, Heidelberg (2007)

Membership Testing: Removing Extra Stacks from Multi-stack Pushdown Automata Nutan Limaye and Meena Mahajan The Institute of Mathematical Sciences, Chennai 600 113, India {nutan,meena}@imsc.res.in

Abstract. We show that fixed membership testing for many interesting subclasses of multi-pushdown machines is no harder than for pushdowns with single stack. The models we consider are MVPA, OVPA and MPDA, which have all been defined and studied in the past. Multi-stack pushdown automata, MPDA, have ordered stacks with pop access restricted to the stack-top of the first non-empty stack. The membership for MPDAs is known to be in NSPACE(n) and in P. We show that the P-time algorithm can be implemented in the complexity class LogCFL; thus membership for MPDAs is LogCFL-complete. It follows that membership testing for ordered visibly pushdown automata OVPA is also in LogCFL. The membership problem for multi-stack visibly pushdown automata, MVPA, is known to be NP-complete. However, many applications focus on MVPA with O(1) phases. We show that for MVPA with O(1) phases, membership reduces to that in MPDAs, and so is in LogCFL.

1

Introduction

Pushdown machines are the machines having a finite control and access to a stack. The languages accepted by such machines are called context-free languages, CFLs. For a fixed machine M , given a string w, the membership problem asks whether w ∈ L(M ). It is of interest due to its implications for parsing and model checking problems. The first polynomial time algorithm for the membership problem for CFLs was given by Cocke, Kasami, and Younger (see for instance [1]). Let us denote the membership problem for the class of languages L by MEM(L). If A is a class of automata accepting the language class L, then we use MEM(L) and MEM(A) interchangeably. The problems log-space many-one reducible to MEM(CFL) define a complexity class called LogCFL [2]. LogCFL is a subclass of P and is also known to be contained in NC, i.e. efficiently parallelizable. The membership problem for many subclasses of CFLs has been studied rigorously. The set of languages log-space many-one reducible to MEM(DCFL), where DCFL denotes deterministic context-free languages, define the complexity class LogDCFL which is a subclass of LogCFL [2]. It is also known that the membership problems for linear and deterministic linear context-free languages, MEM(LIN) A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 493–504, 2009. c Springer-Verlag Berlin Heidelberg 2009 

494

N. Limaye and M. Mahajan

and MEM(DLIN), are complete for the complexity classes nondeterministic and deterministic log-space, NL and Log respectively [3,4]. Another interesting subclass of CFLs is visibly pushdown languages, VPLs ([5,6]). These are the languages accepted by visibly pushdown automata (VPA) which are -moves-free pushdown automata whose stack behaviour is dictated solely by the input letter under consideration. They are also referred to as input-driven PDA. MEM(VPL) is known to be complete for the class NC1 [7] of languages accepted by families of polynomial-size log-depth bounded fan-in circuits. A natural generalisation of pushdown machines is pushdown machines with more than one stack. This generalisation, unfortunately, is not smooth in terms of the power of these machines: A pushdown automaton with two or more stacks is known to recognise all recursively enumerable languages. The model in its full generality is thus intractable. However, for certain model checking applications, pushdown automata with two or more stacks are useful. Hence, some restrictions of multi-stack machines have been considered in the literature. One possible restriction is a 2-stack VPA. One can consider various models depending on whether to allow simultaneous stack changes or depending on the order of accessing the stacks. Such models indeed have been considered recently (see e.g. [8,9]). A language-theoretic study, as well as the membership problem complexity for these models, are important. Here we focus on the membership problem for three different models which have been defined and studied in the literature. The first model is one recently considered by La Torre et al. [9]: a pushdown machine equipped with two stacks where the access to both the stacks is completely dictated by the input alphabet. This is a natural generalisation of VPLs and a proper restriction of general pushdown automaton having more than one stack. They call such machines multi-stack visibly pushdown machines, MVPA. In their definition, these machines cannot simultaneously access both stacks. On reading any input letter, the MVPA either pushes on one of the stacks or pops from one of the stacks. A phase of the input string is a substring such that while reading it, all the pop moves of the machine are on the same stack. In [9], it is shown that MEM(MVPL), where MVPL denotes the class of languages accepted by MVPA, is NP-complete. The proof of NP hardness is a reduction from an instance of SAT. For a fixed MVPA M , a string w is constructed from an n-variable formula such that it has n phases. That the number of phases depends on the input formula is important for the proof of hardness. In this paper, we consider a restriction of the above problem, where the number of phases is a constant. We define another version of the membership problem, MEM(MVPLk ). For a fixed MVPA M and fixed positive integer k, the problem MEM(MVPLk ) is to decide whether a given w ∈ Σ ∗ is in Lk (M ), where Lk (M ) denotes the language {w ∈ Σ ∗ | w is accepted by M with ≤ k phases }. This restriction of MVPA, where the number of phases is bounded, is also useful for many applications and has been defined and considered in [9]. The class is known to generalise VPLs and is properly contained in context-sensitive languages. In this paper, we show that the problem MEM(MVPLk ) is in LogCFL.

Membership Testing: Removing Extra Stacks

495

In order to show this, we need another model of multi-pushdown machines defined by Cherubini et al. [10]. They define a restriction of multi-pushdown machines wherein there is an order given to the stacks of the machine. The machine is allowed to push on any stack. However, pop moves are allowed only on the first non-empty stack. We denote such machines by PDn , where n is the number of stacks in the machine. We denote the class of languages accepted by these as LPDn . A restriction of PDn , namely PD2 , was studied in [11], where it was shown that MEM(PD2 ) is in P. Later, in [12], a P-time upper bound for MEM(PDn ) was established. We give a reduction from MEM(MVPLk ) to MEM(PDk ). We then prove a LogCFL upper bound for MEM(PDk ). This improves the Ptime upper bound of [12]. Also, combined with our previous reduction, this gives a LogCFL upper bound for the problem MEM(MVPLk ). The languages accepted by MVPA within two phases are a proper subclass of context sensitive languages, a proper generalisation of VPLs, and are incomparable with CFLs. Hence, this implies the same upper bound as for CFLs for an incomparable class. However, we do not know if MEM(MVPAk ) for any fixed k is hard for LogCFL. Recently, Carotenuto et al. [8] defined another class of two-stack pushdown machines, 2-OVPA. Like MVPAs, these machines have a visible access to their stacks, i.e. the stack movement is completely dictated by the input alphabet. There is also an order among the stacks and the second stack is popped only if the first is empty. This model is interesting because emptiness and inclusion are decidable, and languages accepted by such machines form a Boolean algebra [8]. The generalisation where the number of stacks is k, k-OVPA, is also considered in [8]. The language class accepted is contained in LPDk . Thus, the LogCFL upper bound we prove also applies to this language class. The main results of our paper can be summarised as follows: Theorem 1. For every fixed k ≥ 1, MEM(MVPLk ) ≤ MEM(PDk ). Theorem 2. For every fixed k ≥ 1, MEM(PDk ) is in LogCFL. Corollary 1. ∀k ≥ 1, MEM(MVPLk ) and MEM(k-OVPA) are in LogCFL.

2

Preliminaries

Circuits and Complexity. A Boolean circuit Cn on n inputs is a directed acyclic graph, with a designated sink (out-degree zero vertex) called the output gate. All the vertices except sources (in-degree zero vertices) are labelled by ∨ and ∧. Sources are labelled by {0, 1} or by predicates of the form [xi , a, 1, 0] where i ∈ [n]. Such a predicate takes the value 1 if xi = a and 0 otherwise1 . A Boolean circuit C can be unwound into a tree TC (by duplicating nodes). A proof tree T  of C on input w is a subtree of TC with the following properties: (1) The output gate is in T  . (2) For every ∨-gate in T  , one of its children is in 1

This convention of labelling leaves with predicates is used, for e.g. , in [13], to deal with languages over non-binary alphabets.

496

N. Limaye and M. Mahajan

T  . (3) For every ∧-gate in T  , all its children are in T  . (4) All the nodes in T  evaluate to 1 on input w. A proof tree exists if and only if Cn accepts w. In general the proof tree could be of size exponential in n. C is said to have poly-proof-tree-size if whenever a string w is accepted by C, there is a proof tree on w of size poly(|w|). The complexity class LogCFL is the class of languages log-space many-one reducible to some CFL, and is known to be equivalent to the class of languages accepted by circuits having polynomial sized proof trees. See e.g. [2,14,15]. Visible two stack machines ([9]). An MVPA M is a pushdown machine having two stacks, where the access to the stacks is restricted in the following way: The input alphabet Σ is partitioned into 5 sets. A letter from Σcj causes a push move on stack j, that from Σrj forces a pop move on stack j, and both the stacks are left unchanged on letters from Σi . (The subscripts c, r, i denote call, return and internal respectively.) Formally, an MVPA M = (Q, Σ, Γ, δ, q0 , F ) is a two-stack nondeterministic pushdown machine where Q is a set of finite states, Σ is the finite alphabet which is a union of 5 disjoint sets Σc0 , Σr0 , Σc1 , Σr1 , Σi , q0 is the initial state, F ⊆ Q is a set of final states, Γ is the finite stack alphabet containing a special bottom-of-stack symbol ⊥ that is never pushed or popped, and δ has the following structure: δi ⊆ Q × Σi × Q, and for j ∈ {0, 1}, δcj ⊆ Q × Σcj × Q × Γ \ {⊥} and δrj ⊆ Q × Σrj × Γ × Q. The machine is allowed to pop on an empty stack; that is, on reading a letter from Σrj and seeing ⊥ on the jth stack top, the machine can proceed with a state change leaving the ⊥ untouched. A phase is a substring of the input string w ∈ Σ ∗ during which pop moves happen only on one of the stacks. Define the set PHASEk = {w | w ∈ Σ ∗ , number of phases in w ≤ k} Clearly, for any fixed partition of Σ, PHASEk is a regular set. Let M be a fixed MVPA M and k a fixed positive integer. Its k-phase language Lk (M ) is defined as Lk (M ) = L(M ) ∩ PHASEk . By taking a direct product of a finite state automaton accepting PHASEk with MVPA M , we can obtain an MVPA M  = M, k such that L(M  ) = Lk (M  ) = Lk (M ). In Section 3, we assume that the given MVPA M satisfies L(M ) = Lk (M ). Ordered multi-stack machines and grammars ([10,11,12]). A PDk M = (Q, Σ, Γ, δ, q0 , Z0 , F ) is a k-stack pushdown machine where Q, Σ, q0 , Z0 , F are as usual, and the transition function δ is of the form δ ⊆ Q×(Σ ∪)×Γ ×Q×(Γ ∗)k . A configuration is a (k + 2)-tuple, q, w, γ1 , . . . , γk where q ∈ Q, w ∈ Σ ∗ , and γi ∈ Γ ∗ for each i represents the contents of the ith stack. The initial configuration on word x is q0 , x, Z0 , , . . . ,  . A configuration is called a final configuration if q ∈ F . If there is a transition (q  , α1 , . . . , αk ) ∈ δ(q, a, A), the machine in state q can read a letter a from the input tape, pop A from the first non-empty stack, push αi on stack i for each i ∈ [k], and move to state q  . Formally, q, aw, , . . . , , Aγi , . . . , γk  q  , w, α1 , . . . , αi−1 , αi γi , . . . , αk γk .

Membership Testing: Removing Extra Stacks

497

If (q  , α1 , . . . , αk ) ∈ δ(q, , A) then q, w, , . . . , , Aγi , . . . , γk  q  , w, α1 , . . . , αi−1 , αi γi , . . . , αk γk . The PDk M accepts a string w if it can move from q0 , w, Z0 , , . . . ,  to some q, , γ1 , . . . , γk where q ∈ F . The set of all the strings accepted by M is the language accepted by M , denoted L(M ). Theorem 3. ([12]) For a fixed PDk , given an input string w ∈ Σ ∗ , checking if w ∈ L(M ) is in P. i.e. MEM(PDk ) ∈ P. In [11], PDk are characterized by grammars. We describe the D2 -grammars that correspond to languages accepted by PD2 . A D2 -grammar G is a 4-tuple G = (N, Σ, P, S) where N, Σ, S are as usual, and P has productions of the form: A → w(α)(β) where A ∈ N , w ∈ Σ ∗ and α, β ∈ N ∗ . Sentential forms in a derivation are of the form x(α)(β) where x ∈ Σ ∗ , α, β ∈ ∗ N . The initial sentential form is (S)(). If A → w(α)(β) is a production rule, then w (Aα )(β  ) ⇒ w w(αα )(ββ  ) and w ()(Aβ  ) ⇒ w w(α)(ββ  ) are the only valid derivations using this rule. Note that only leftmost derivations are allowed. We say that A ⇒∗ w(α)(β) if (A)() ⇒∗ w(α)(β) and that A ⇒∗ w if (A)() ⇒∗ w()(). The language generated is the set L(G) = {w | S ⇒∗ w}. Theorem 4. ([11]) Every D2 -grammar G has an equivalent normal form D2 grammar G where each production is of one of the following types: – A → (BC)(); A, B, C ∈ N (branching production) – A → ()(B); A, B ∈ N (chain production) – A → a; A ∈ N, a ∈ Σ. (terminal production). A derivation in such a grammar is said to be a normal form derivation if whenever a non-terminal A is rewritten by a chain production, say A → ()(B), then that occurrence of B is eventually rewritten by either a branch production or a terminal production. That is, no variable participates in two chain rules. For every derivation, there is an equivalent normal form derivation [11]. A typical derivation in this grammar arising from the use of a branching production produces non-contiguous substrings. Say A → (BC)() ∈ P . Also say B ⇒∗ β1 ()(β) ⇒∗ β1 β2 ()() and C ⇒∗ γ1 ()(γ) ⇒∗ γ1 γ2 ()(). Then A ⇒ (BC)() ⇒∗ β1 (C)(β) ⇒∗ β1 γ1 ()(γβ) ⇒∗ β1 γ1 γ2 ()(β) ⇒∗ β1 γ1 γ2 β2 ()(). Thus, we say that in the string β1 γ1 γ2 β2 , the substring β1 β2 is produced by B with a gap, and the gap is filled by C with the substring γ1 γ2 . A chain production does not explicitly give rise to a gap in the string. However, the application of a chain production swaps the order of substrings being produced by the non-terminals in the first list. Say A → ()(B) and B ⇒∗ β; i.e. A produces a string β via a chain rule. Also say C ⇒∗ γ. Consider a sentential form w(AC)(δ). The string β produced by A appears in the final string after the string γ that is produced by C. That is, we get w(AC)(δ) ⇒ w(C)(Bδ) ⇒∗ wγ()(Bδ) ⇒∗ wγβ()(δ). Hence when A produces a string via a chain production, we assume that β has a gap (of length 0) at the beginning (before β). Thus, a chain rule always results in a gap at the beginning.

498

N. Limaye and M. Mahajan

Consider a terminal rule A → a. Say A appears in some list in a sentential form. The terminal a produced by A appears before all the strings produced by all the non-terminals that follow A in its list. Consider sentential form w(AC)(δ). Then we get w(AC)(δ) ⇒ wa(C)(δ) ⇒∗ waγ where C ⇒∗ γ. Thus, a terminal production produces a gap (of length 0) at the end (i.e. after the terminal). Ordered, visible two stacks machines ([8]). 2-OVPA are pushdown machines with two stacks, access to both of which is dictated by the input alphabet. The input alphabet Σ is a union of 8 disjoint finite sets: except for simultaneous pops on both stacks, all other combinations are allowed. Also the stacks are accessed in an ordered manner i.e. a pop is allowed on the second stack only if the first stack is empty. k-stack versions, k-OVPA, are defined similarly [8]. k-OVPA are essentially restrictions of PDk , with the exception that they can also make moves when their stacks are empty. See [8] for formal definitions.

3

Reduction from MEM(MVPLk) to MEM(PDk)

In this section, we consider the problem MEM(MVPLk ) and establish Theorem 1. The simplest case is when k = 1; for all fixed MVPA M , L1 (M ) ∈ VPL. Since VPLs are known to be in NC1 [7], for which membership in a fixed regular language is complete [16], MEM(MVPL1 ) reduces to MEM(NFA), where NFA are nondeterministic finite-state automata. But a PD0 is precisely an NFA. Hence MEM(MVPL1 ) reduces to MEM(PD0 ). For k > 1, we reduce this problem to MEM(PDk ). As described in Section 2, we assume that Lk (M ) = L(M ). We convert M into a multi-pushdown machine N having k stacks, called Maini for 1 ≤ i ≤ k, and show that L(M ) reduces to L(N ) (via logspace many-one reductions). Consider a phase i in which stack-j (j ∈ {0, 1}) of machine M is being popped. The PD works in two stages – mimic stage and buffer stage. (Exception: phase k has only a mimic stage.) In the Mimic stage, Maini and Maini+1 contain the contents of stack j and 1 − j respectively and mimic the moves of machine M on these two stacks. The rest of the stacks are empty. (In particular for all l < i, Mainl are empty.) In the Buffer stage, Maini+1 is marked with a special symbol. The contents of Maini are popped and are pushed onto top of the special symbol (in reversed order), and then popped and pushed into Maini+2 . Thus, the contents of Maini are transferred into Maini+2 in the same order. Note that, the contents of Maink need not be popped at all since there is no subsequent phase, and hence k stacks suffice in N . To carry out these phases, the input string is padded with some new extra letters by a function f . On reading these letters, N does the necessary transfers. As the next phase expects to pop stack Maini+1 , after such a transfer all the stacks are ready for next processing step. More formally, Lemma 1. Fix a MVPA M and an integer k. There exist a PD2k+2 N and a function f ∈ Log, such that ∀w ∈ Σ ∗ , w ∈ Lk (M ) ⇔ f (w) ∈ L(N ).

Membership Testing: Removing Extra Stacks

499

A small technical difficulty is that MVPAs are allowed pop operations on empty stacks, but PDs cannot make any move if all stacks are empty. If a prefix of an input string has unmatched pop letters (pops on empty stack), then during the mimic phase the simulating machine N may get stuck. To prevent this, we pad the input string with a suffiently long prefix that causes push moves on both the stacks. This boosts the heights of the stacks and ensures that the resulting string has no unmatched pop move. Formally, we show the following: Lemma 2. Fix a MVPA M . There exists another MVPA M  and a function g ∈ Log such that for every string w ∈ Σ ∗ , w ∈ L(M ) ⇔ g(w) ∈ L(M  ), M on w and M  on g(w) have the same number of phases, and M  never pops or pushes on empty stack. We will call strings obtained by reduction g as extended strings and machine M  thus obtained a good MVPA. By Lemma 2, we assume that we have a good MVPA M that never uncovers the bottom-of-stack marker (except at the beginning) on either stack on the inputs that it receives. For an extended string w, let htj (w) denote the height of stack-j of a good MVPA M after having processed the string w. Here, j ∈ {0, 1}. To compute the function f in Lemma 1, we need the values htj (x) for each prefix x of w. These values are easy to compute: Proposition 1. For any extended input string w, computation of htj (w) and demarcation of the string into its first k phases can be done in Log. Suppose we have the extended string w = w1 w2 ...wk (on the extended alphabet Σ) already marked with the phases. That is, wi is the string processed in the ith phase, and the individual strings w1 , w2 , . . . , wk are known. Let ki denote the height of the stack that was popped in phase i, after having processed the ith phase. We have ensured that ki ≥ 1 for all i. Let U, V, W, Z, # be new letters not in Σ. Then f is defined as below. (No padding is needed after wk .) f (w) = Zw1 #U k1 +1 V k1 +1 #W w2 #U k2 +1 V k2 +1 #W . . . wi #U ki +1 V ki +1 #W . . . wk . For the PDk N = (Q , Σ  , Γ  , δ  , q0 , F  ), Q consists of 3k copies of the states of M , 3 copies for each phase. The first copy is used during the mimic stage and the second and third copies are used for the first and the second steps in the buffer stage respectively. The padding symbol # is used in order to mark the stack Maini+1 with a special marker before the buffer-stage begins and then to pop the marker after the contents on top of it are moved into Maini+2 . Also Γ  consists of k copies of Γ , with the i-th copy used as the stack alphabet for Maini . Formally, the invariant maintained with respect to M can be stated as follows: Lemma 3. Machine M on input w has a non-deterministic path ρ in which for each i ∈ [k], after phase i (where phase i pops stack j) βi is on stack j, αi is on stack 1 − j and M is in state q if and only if machine N has a non-deterministic path ρ along which for each i ∈ [k], after reading the prefix up to and including wi in f (w), (1) βi Z0 is on Maini , (2) αi Z0 is on Maini+1 , (3) all the other stacks are empty, and (4) the state reached is [q (1) , i]. That is, the runs of machines M and N are in one-to-one correspondence. It follows that, M accepts w if and only if N accepts f (w); hence Lemma 1.

500

4

N. Limaye and M. Mahajan

The LogCFL Upper Bound for MEM(PDk)

In this section, we show that membership testing for a fixed PDk is in LogCFL. The main structure of our LogCFL algorithm closely follows that of the Ptime algorithm for membership testing for PD2 as given in [11]. So we first describe it in some detail (Section 4.1), following the presentation from [17]. We then give (Section 4.2) a different implementation of the same algorithm and improve the upper bound to LogCFL, thus establishing Theorem 2 for k = 2. A P-time algorithm for MEM(PDk ) is given in [12]. It is very similar to the algorithm from [11]. In Section 4.3, we discuss the changes needed to be made in our implementation for the LogCFL bound to hold for all fixed k, thereby establishing Theorem 2. 4.1

Outline of the P-Time Algorithm of [11,17]

The P-time algorithm uses the characterization of PD2 via D2 grammars in normal form, and normal-form derivations, as described in Section 2. Given an input w ∈ Σ ∗ , the algorithm needs to keep track of substrings of w being produced with gaps. This is done as follows: A table T in constructed such that any entry in the table is indexed by four indices, T (i, j, r, s). The algorithm fills entries in the table with subsets of N . A non-terminal A is in T (i, j, r, s) if and only if A generates the string wi+1 . . . wj with a gap of length s at position i + 1 + r. Here r is the offset from i + 1 where the gap begins. The table entry T (i, j, r, s) deals with the interval inv = [i + 1, j] modulo the gap interval gap = [i + r + 1, i + r + s]. Let l = j − i denote the total length of the interval and l = j − i − s denote the actual length of the interval under consideration i.e. length of the interval without the gap. The table is filled starting from smaller values of l. Further, the table entries with intervals of the same length l are filled starting from l = 1 going up to l = l. All entries are first initialized to contain the empty set. For fixed values of l and l , we call a tuple i, j, r, s valid for l and l if and only if j = i + l, s = l − l and i + r + s ≤ j (i.e. r ≤ l ). For l = 1 all the entries are filled by the following two rules, using information from the input and the fixed grammar. 1. T (i, i + 1, 1, 0) = {A | A → wi+1 } 2. T (i, i + 1, 0, 0) = {A | A → ()(B), B → wi+1 } In the first (second) rule, the table entries correspond to intervals of size 1, where the zero-length gap is at the end (beginning, respectively). It contains the nonterminals that produce the terminal wi+1 using a terminal (chain, respectively) production. As the value of l increases, depending on the position and size of the gap, various rules are used to fill up the table. For l > 1, the following rules are applied to fill the table entries corresponding to valid tuples: Rule 1: This rule is applied provided the interval size is at least 2, and values of r , s satisfy r < r, s < s < j − i = l.

Membership Testing: Removing Extra Stacks

501

⎫ ⎧ A → (BC)(), ⎬ ⎨ T (i, j, r, s) = T (i, j, r, s) ∪ A B ∈ T (i, j, r , s ), ⎭ ⎩ C ∈ T (i + r , i + r + s , r − r , s) For this update, the algorithm uses values from T (i, j, r , s ) and T (i + r , i + r + s , r − r , s). These values are already available. To see this, note that for T (i, j, r , s ), the actual interval length is j − i − s which is strictly less than l as s > s, and for T (i + r , i + r + s , r − r , s), the interval length is s where s < l. 

Rule 2: T (i, j, 0, s) = T (i, j, 0, s) ∪ {A | A ∈ T (i + s, j, 0, 0)}. This rule is applied when the offset r is zero, i.e. when the gap is on the left. Note that this rule makes no update when the length s of the gap is zero. For this update, the algorithm uses values from T (i + s, j, 0, 0) (for which length of the interval j − i − s < l). This value is already available. Rule 3: T (i, j, r, s) = T (i, j, r, s) ∪ {A | A ∈ T (i, j − s, r, 0)}. This rule is applied when the gap of length s is on the right. This happens when the gap stretches all the way till j, i.e. i + r = j − s. Note that this rule makes no update when the length s of the gap is zero. For this update, the algorithm uses values from T (i, j − s, r, 0) (for which length of the interval is j − s − i < l). These values are already available. Rule 4: T (i, j, 0, 0) = T (i, j, 0, 0) ∪ {A | A → ()(B), B ∈ T (i, j, r , 0)}. This rule is applied when s and r are both zero. And 0 ≤ r ≤ j − i. For this update, the algorithm uses values from T (i, j, r , 0) checking if A → ()(B) and B ∈ T (i, j, r , 0) for some 0 ≤ r ≤ j − i. Now for T (i, j, r , 0), the l and l values are the same as that for T (i, j, 0, 0). So we cannot immediately conclude that the required values are already available. However, for fixed l, l , the P-time algorithm performs steps 1, 2, 3 before the step 4. Steps 2, 3 leave entries unchanged if s = 0. It is sufficient to argue that step 1 in fact puts B in T (i, j, r , 0), which is then used in step 4. Suppose not. i.e. suppose B is written in T (i, j, r , 0) by rule 4. Let r = 0, as rule 4 cannot have been applied if r = 0. Also as B is written in T (i, j, r , 0) by rule 4, there exists a C ∈ N and a rule B → ()(C) such that B ⇒ ()(C) ⇒∗ wi+1 . . . wj . But then the complete derivation is A ⇒ ()(B) ⇒ ()(C) ⇒∗ wi+1 . . . wj . This contradicts the assumption that we have a normal form derivation. Hence, the required values are already available even for this step. After a systematic looping through these indices, finally the entry of interest T (0, n, 0, 0) is filled. If S ∈ T (0, n, 0, 0), then the algorithm returns ‘yes’, else it returns ‘no’. The time complexity of the algorithm is O(n6 ). 4.2

The LogCFL Algorithm (k = 2)

We now give a top-down algorithm to fill up the table T . We will see that it can be implemented by a poly sized circuit having ∧ and ∨ gates and having poly sized proof trees. From [14,2] it follows that this algorithm is in LogCFL. The polynomial time algorithm that fills up the table can be viewed as a polynomial sized circuit. However, this circuit need not have polynomial size

502

N. Limaye and M. Mahajan

proof trees. In particular, the index computations may blow up the proof-tree size. We note that these index computations are independent of the input, and give a way to build a circuit with small proof-trees. For each l ≤ l ≤ n, for all valid tuples corresponding to these values of  l, l , and for each A ∈ N , we introduce 5 gates: an OR gate A, i, j, r, s called 1 2 3 4 a main gate, and 4 intermediate gates XA,i,j,r,s , XA,i,j,r,s , XA,i,j,r,s , XA,i,j,r,s called auxiliary gates. We design the circuit in such a way that A, i, j, r, s = 1 if and only if A ∈ T (i, j, r, s). The root of the circuit is labelled S, 0, n, 0, 0 . The circuit connections are as follows:  k A, i, j, r, s = XA,i,j,r,s k∈[4] 1 XA,i,j,r,s



=





B, i, j, r , s C, i + r , i + r + s , r − r , s

r < r s<s <j−i−r+1 {B, C| A → (BC)()} A, i + s, j, 0, 0 if r = 0 = 0 otherwise A, i, j − s, r, 0 if i + r = j − s = 0 otherwise 1 if r, s = 0 0≤r  ≤j−i,{B| A→()(B)} XB,i,j,r  ,0 = 0 otherwise 

2 XA,i,j,r,s 3 XA,i,j,r,s 4 XA,i,j,r,s

This finishes the description of all the non-leaf gates. The input gates are predicates and their values are propagated via the following depth-1 circuit.  [i, a, 1, 0] A, i, i + 1, 1, 0 = {a| (A→a∈P )}

A, i, i + 1, 0, 0

=



[i, a, 1, 0]

{a| ∃B(B→a∈P )∧(A→()(B)∈P )}

Note that the above connections give an acyclic digraph of depth O(n2 ). It is now easy to see the following claim, and hence the correctness of the above circuit follows from the correctness of P-time algorithm. Lemma 4. A, i, j, r, s = 1 if and only if A ∈ T (i, j, r, s). The LogCFL bound for MEM(PD2 ) now follows from the following claim: Claim. The circuit constructed above has polynomial-size proof-trees. 4.3

The LogCFL Algorithm for MEM(PDk )

The grammars [10] corresponding to PDk have rules with a single non-terminal belonging to one of the k lists on the left hand side and at most k lists of nonterminals on the right hand side. The normal form of the grammar is as follows:

Membership Testing: Removing Extra Stacks

503

– (A)h → (BC)1 ; k ≥ h ≥ 1 (branch production; always expands into list 1) – (A)h → (B)g ; k ≥ g > h ≥ 1 (chain production; from list h to a later list g) – (A)h → a; a ∈ T ; k ≥ h ≥ 1 (terminal production) Now, any typical string derived by a non-terminal can have as many as 2k−1 gaps; see [12]. If (A)h → (BC)1 is a branch rule, and B, C derive strings γ and δ respectively, then the string derived from A is a systematic merge of γ and δ. In the case when k = 2, only one gap was possible, whereas here we need to keep track of 2k−1 gaps to interleave γ and δ properly. Arrays r˜ and s˜, of length 2k−1 each, keep track of the off-sets and the lengths of the gaps. Each table entry is indexed by i, j, r˜, s˜, as in the case k = 2. But now the tables are 2k + 2 dimensional (as each r˜ and s˜ are 2k−1 length arrays). The table entries contain non-terminals and they are filled in such a way that a non-terminal A belongs to a certain entry Ti,j,˜r,˜s if and only if the string wi . . . wj with gap off-sets as in r˜ and gap sizes as in s˜ can be obtained from A. The rules for filling up the table are slightly more complicated. However, they simply involve some index manipulations. These can be implemented as we did for k = 2. Once these rules are established, the order of filling up the entries and hence the rest of the algorithm is exactly the same. Thus, we obtain Theorem 2. 4.4

Bounds for MVPA and OVPA

From Theorems 1 and 2, it follows that MEM(MVPAk ) is in LogCFL. To see this bound for MEM(k-OVPA), Theorem 2 should suffice, since as claimed in [8], k-OVPA are a special case of PDk . However, there is a slight subtlety here. k-OVPA are allowed to “pop” on an empty stack: if all stacks are empty (they contain only the special letter ⊥), then the k-OVPA can still proceed with its computation even on a return letter. However, a PDk in a similar configuration is stuck and cannot make any move. So it is technically not completely correct to say that k-OVPA are PDk . However, we can handle this exactly as we did for MVPA in Lemma 2, reducing MEM(k-OVPA) to MEM(PDk ).

5

Discussion

Our results show that adding more stacks to a PDA does not make the fixed membership problem harder than that for ordinary pushdown automata if stack access is restricted to visible behaviour with O(1) phases, or if the the stacks are ordered and the stack pop access is restricted to the first non-empty stack. Some interesting questions remain unanswered: What complexity classes are characterized by MEM(MVPAk ) and MEM(OVPA)? These problems lie somewhere between NC1 and LogCFL. And what is the complexity of the general membership problem for these models, where the machine and the word are both part of the input? Acknowledgments. The authors are grateful to the referees for presentationrelated comments, and for noting that Theorem 1 needs only k stacks, not 2k −2.

504

N. Limaye and M. Mahajan

References 1. Hopcroft, A., Motwani, R., Ullman, J.: Introduction to Automata Theory, Languages and Computation. Addison-Wesley, Reading (2001) 2. Sudborough, I.H.: On the tape complexity of deterministic context-free language. Journal of Association of Computing Machinery 25(3), 405–414 (1978) 3. Sudborough, I.H.: A note on tape-bounded complexity classes and linear contextfree languages. Journal of Association of Computing Machinery 22, 499–500 (1975) 4. Holzer, M., Lange, K.J.: On the complexities of linear LL(1) and LR(1) grammars. In: 9th International Symposium on Fundamentals of Computation Theory FCT, London, UK, pp. 299–308. Springer, Heidelberg (1993) 5. Alur, R., Madhusudan, P.: Visibly pushdown languages. In: 36th ACM Symposium on Theory of Computing (STOC 2004), pp. 202–211 (2004) 6. Mehlhorn, K.: Pebbling mountain ranges and its application to DCFL recognition. In: 7th International Colloquium on Automata, Languages and Programming, pp. 422–432 (1980) 7. Dymond, P.W.: Input-driven languages are in log n depth. Information Processing Letters 26, 247–250 (1988) 8. Carotenuto, D., Murano, A., Peron, A.: 2-visibly pushdown automata. In: Harju, T., Karhum¨ aki, J., Lepist¨ o, A. (eds.) DLT 2007. LNCS, vol. 4588, pp. 132–144. Springer, Heidelberg (2007) 9. La Torre, S., Madhusudan, P., Parlato, G.: A robust class of context-sensitive languages. In: 22nd Symposium on Logic in Computer Science, pp. 161–170 (2007) 10. Cherubini, A., Breveglieri, L., Citrini, C., Crespi Reghizzi, S.: Multipushdown languages and grammars. International Journal of Foundations of Computer Science 7(3), 253–292 (1996) 11. Cherubini, A., Pietro, P.S.: A polynomial-time parsing algorithm for a class of non-deterministic two-stack automata. In: 4th Italian Conference on Theoretical Computer Science, pp. 150–164 (1992) 12. Cherubini, A., Pietro, P.S.: A polynomial-time parsing algorithm for k-depth languages. Journal of Computer and System Sciences 52(1), 61–79 (1996) 13. Allender, E., Jiao, J., Mahajan, M., Vinay, V.: Non-commutative arithmetic circuits: depth reduction and size lower bounds. Theoretical Computer Science 209, 47–86 (1998) 14. Ruzzo, W.: Tree-size bounded alternation. Journal of Computer and System Sciences 21, 218–235 (1980) 15. Vollmer, H.: Introduction to Circuit Complexity: A Uniform Approach. Springer, New York (1999) 16. Barrington, D.: Bounded-width polynomial size branching programs recognize exactly those languages in NC1 . Journal of Computer and System Sciences 38, 150– 164 (1989) 17. Pietro, P.S.: Two-stack automata. Rapporto Interno n. 92-073, Dipartimento Di Elettronica e Informazione, Politecnico di Milano, Milano (October 1992), http://home.dei.polimi.it/sanpietr/pubs/twostack92.ZIP

Automata on Gauss Words Alexei Lisitsa, Igor Potapov, and Rafiq Saleh Department of Computer Science, University of Liverpool, Ashton Building, Ashton St, Liverpool L69 3BX, UK Abstract. In this paper we investigate the computational complexity of knot theoretic problems and show upper and lower bounds for planarity problem of signed and unsigned knot diagrams represented by Gauss words. Due to the fact the number of crossing in knots is unbounded, the Gauss words of knot diagrams are strings over infinite (unbounded) alphabet. For establishing the lower and upper bounds on recognition of knot properties we study these problems in a context of automata models over infinite alphabet.

1

Introduction

Algorithmic and computational topology is a new growing branch of modern topology. Much of the recent effort has focused on classifying the inherent complexity of topological problems. In this paper we investigate the computational complexity of knot theoretic problems and show upper and lower bounds for planarity problem of signed and unsigned knot diagrams. The main goal of proposed approach is to give a new insight on knot problems and characterise knot problems according to their computational complexity. The results presented in this paper were achieved by a combination of methods from knot theory, automata theory and computational complexity. Knot theory is the area of topology that studies mathematical knots and links. A knot (a link) is an embedding of a circle (several circles) in 3-dimensional Euclidean space, R3 , considered up to a smooth deformation of an ambient space. It is well established and exciting area of mathematical research with strong connections with topology, algebra and combinatorics. Examples of interactons between knot theory and computer science include works on formal language theory [1], quantum computing [2,3,4] and computational complexity [5]. Knots can be described in various ways, including various discrete representations. For example, a common method of describing a knot is a planar diagram called a knot diagram. A knot diagram is a projection of the knot onto a plane, where at each crossing we must indicate which section is ”over” and which is ”under”, so as to be able to recreate the original knot. As an additional information we can also add a label (“‘+“ or “-“) to each of the crossing for representing orientation of its strands. A knot diagram can be encoded as a string of symbols Oi ’s (over) and Ui ’s (under) also known as Gauss word. The procedure of writing a Gauss word can be described as follows: Starting from a base point on the circle, write down the A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 505–517, 2009. c Springer-Verlag Berlin Heidelberg 2009 

506

A. Lisitsa, I. Potapov, and R. Saleh

labels of the crossings in the counterclockwise direction, e.g. the trefoil K can be defined by a Gauss word U1 + O2 + U3 + O1 + U2 + O3 + , where indices indicate an (arbitrary) order of the crossings in the knot diagram and signs stand for orientation of each crossing. Likewise, links can be represented by several Gauss words - one for each component of the link. As you can see the construction of the Gauss word is quite straightforward by reading visited crossings travelling along a circle. The inverse problem of constructing a knot from some strings of symbols from the set of Oi ’s and Ui ’s is harder and it is not always possible. It may happen that some Gauss words would not correspond to any classical (planar) diagrams. In such case we say that a Gauss word corresponds to a non-planar knot where any of its diagram should contain virtual crossings (i.e. which are not listed in the Gauss word). Most of the problems of recognising knots properties (such as virtuality, unknottedness, equivalence) are known to be decidable, with different time complexity. However their complexity in terms of computational power of devices needed to recognise the knot properties was not studied yet. In this paper we address this problem and provide first known bounds for some knot problems in this context. The central problem which we are studying in this paper is to determine whether a given Gauss word corresponds to planar or non-planar knot. Due to the fact the number of crossing in knots is unbounded, the Gauss words of knot diagrams are strings over infinite (unbounded) alphabet. In this context we cannot estimate computational complexity in terms of classical models over finite alphabets and need to consider a new hierarchy of languages and models over infinite alphabet. Such models were recently introduced in [6,7]. In Section 2 we describe and extend the models of automata over infinite alphabet that we used for establishing the lower and upper bounds on recognition of knot properties. Then in Section 3 we show that the language of planar (nonplanar) signed Gauss words can be recognised by deterministic two-way register automata by simulation of recently discovered linear time algorithm proposed in [8]. Due to the fact that the algorithm presented in [8] allows to check planarity property not only for knots but also for links we think that the proposed idea of recognising planarity by register automata can be extended for links after some minor modification. The result is final in a sense that the power of nondeterministic one-way register automata is not even enough to recognise whether an input is a Gauss word. We also conjecture that planarity problem for unsigned Gauss words is harder than the the same problem for signed Gauss words and cannot be solved by register or k-pebble automata over infinite alphabet. For the case of unsigned Gauss words we provide the upper bound by showing that planarity can be checked by deterministic linearly bounded memory automata.

2

Automata over Infinite Alphabets

Let D be an infinite set called an alphabet. A word, or a string over D, or shortly, D-word or D-string is a finite sequence d1 , . . . dn where di ∈ D, i = 1, . . . , n. A language over D (D-language) is a set of D-words. For a word w and a symbol

Automata on Gauss Words

507

d denote by | w |d the number of occurrences of d in w. As usual | w | denotes the length of the word w. A language L over an infinite alphabet D is called n-bounded if and only if there is a constant n ∈ N such that for any w ∈ L and for any d ∈ D | w |d ≤ n. All languages we consider are bounded languages. 2.1

Register Automata

Register automata are finite state machines equipped with a finite number of memory cells called registers which may hold values from an infinite alphabet. It is one of the weakest models of automata over infinite alphabets introduced in [6] and studied further in [7]. Definition 1 ([7]). A non-deterministic two-way k-register automaton over an infinite alphabet D is a tuple (Q,q0,F,τ 0 ,P) where Q is a finite set of states, q0 ∈ Q is the initial state,F ⊆ Q is the set of final states, τ 0 : {1,...,k}→ D ∪ {, }is the initial register assignment and P is a finite set of transitions of the forms: 1) (i, q) → (q  , d) (If a current state is q and the observed symbol on the tape equals to a value in the register i then enter the state q  and move along the string according to specified direction d;) 2) q → (q  , i, d) (If a current state is q and the observed symbol on the tape does not equal to any value held in registers then enter the state q  , copy the current symbol to a specified register i and move along the string according to the specified direction d, where i ∈ {1, .., k}, q, q  ∈ Q and d ∈ {stay, lef t, right}.) Given a D-word d delimited by symbols , on the input tape an automaton starts in a state q0 and in the position of the first letter of d and applies nondeterministically any applicable rules. As usual, if automaton is able ever to reach a state q ∈ F it accepts the word, otherwise the word is rejected. The set of all accepted words forms a language recognisable by an automaton. An automaton is deterministic if in each configuration at most one transition applies. For the purpose of this paper we modify the definition of register automata from [7] by allowing more general transition rules that allows replication of the same value in different registers. This does not affect the computational power of the model (see Lemma 1 below), but makes the design of such automata for various recognition problems much more natural and easier. Similar modifications (in more general setting) have appeared in [9,10]. We define modified two-way k-register automata by adding to the definition above two extra types of transitions rules: 3) (i, q) → (q  , j, d) If a current state is q and the observed symbol equals to a value in the register i then enter the state q  , copy the current symbol to a register j and move along the string according to specified direction d; 4) q → (q  , d) If a current state is q and the observed symbol does not equal to any value held in registers then enter the state q  and move along the string according to specified direction d, where i, j ∈ {1, .., k}, q, q  ∈ Q and d ∈ {stay, lef t, right}.

508

A. Lisitsa, I. Potapov, and R. Saleh

Lemma 1. The models of original register automaton and modified register automaton over an infinite alphabet are equivalent. Proof. We show that two extra types of rules of the modified model can be simulated by the original automata. The rule of type 4 is simulated by adding one extra dummy register k + 1 and replacement of rules of modified automata of the form q → (q  , d) by a pair of rules (k + 1, q) → (q  d) and q → (q  , k + 1, d). If a value of the register k + 1 is equal to the observed symbol then the rule (k + 1, q) → (q  d) is applicable otherwise the rule q → (q  , k + 1, d) is applicable. Also we replace the rule q → (q  , i, d) of type 2 in the modified automata model by a pair of rules; original type 2 rule q → (q  , i, d) and type 3 rule (k +1, q) → (q  d). The rule of type 3 (i, q) → (q  , j, d) of the modified model that allows storing the same value in different registers, can be simulated in original model by using the following construction. The state of the registers of the modified automaton, that is a sequence of not necessarily different values R = [r1 , r2 , . . . , rk+1 ] is represented in the simulating automaton as a pair: – the set of unique values U = {r1 , r2 , . . . , rk+1 }, and – the surjective mapping φ : {1, . . . , k + 1} → U The content of U is kept in the registers and since the mapping φ is finite, it can be kept in the finite state control. Now it is straightforward to simulate the effects of all possible types of rules, including the type 3, in terms of pairs U, φ. We omit obvious details.   Pebble Automata. As an alternative model of automata over infinite alphabet, pebble automata(PA) was introduced in [11] and further studied in [7]. We follow the definitions in [7]. In this model, instead of registers, finite state machines are equipped with the finite set of pebbles which can be placed on the input string and later lifted following the stack discipline. That means pebbles are numbered from 1 to k and pebble i + 1 can only be placed when pebble i has already been placed on the string and vice-versa, pebble i can only be lifted if i + 1 is not on the string. Further assumption is that the pebble with the highest number acts as a head, so an automaton has an access to the symbol of the string under such a pebble and to the information on which other pebbles are located at the same position. The transition of pebble automata depends on the following: the current state, the pebbles placed on the current position of the head, the pebbles that see the same symbol as the top pebble. The effect of the transition is the change of a state, movement of the head and, possibly, removal of the head pebble, or placement of the new pebble. As usual acceptance of a word is defined as reachability of one of the final states. As expressive power concerned, in general pebble automata are incomparable with register automata [7]. We will show, however, in the Section 3 that over a class of bounded languages, including all languages of our interest, PA can be effectively simulated by RA.

Automata on Gauss Words

509

Linearly Bounded Memory Automata. In all models above the input can be thought of as given on the input tape which can only be read, but not written on. Linearly bounded automata (LBMA) is an extension of register automata with the input tape. The automaton can read and write in the tape cells the symbols of an infinite alphabet. The input is given on the initial part of the tape and for the input size n, the size of the tape is assumed to be O(n), i.e. linearly bounded. Types of rules of LBMA include all types of rules of (modified) RA and additional rules allowing to write on the tape. For every form L → (. . .) of rules of the (modified) RA model the following is a form of rule for LBA: L → (. . . , i), where i ∈ {1, . . . k}. The effect of application of the latter is the same as of the former, plus the automaton writes the content of the register i in the current position on the tape before possible head movement. Words and Data Words. In previous works on the computational models on infinite alphabets it has been acknowledged that in many situations it is natural to consider infinite alphabets as the subsets of Σ×Δ where Σ is a finite set and Δ is an infinite set. Thus, the symbol here is an ordered pair (a, b). The words over such alphabets are called data words [12]. In the definition of automata over data words, it is sensible to assume that when an automaton reads a symbol (a, b) it has a direct access to both components of the pair. For this purpose, the form of transition rules can be adapted to include one extra argument on the left-hand sides. For example, the rule (c, i, q) → (q  , d) is read as ”if an automaton is in a state q and observes the symbol (c, a) and a is the content of the register i then the automaton can change the state to q  and move the head along the direction d.” It should be clear now how to modify the definitions of all above models to work over data words.

3 3.1

Recognisability of Knot Properties The Language of Gauss Words

Knots which are defined as embeddings of a circle in 3-dimensional Euclidean space can be faithfully represented by finite structures, such as graphs or words. One of such discrete representations is a Gauss code, which is a word of crossing labels O (”over”) and U (”under”) with appropriate indices, which can be read of the projection of the knot on the plane. Given orientation of the plane one can distinguish between left and right-handed crossings (see Figure 1) which are labelled by signs − and +, respectively. Definition 2. An unsigned Gauss word w is a data word over the alphabet Σ×N where Σ = {U, O}, such that for every n ∈ N either – |w|(U,n) = |w|(O,n) = 0, or – |w|(U,n) = |w|(O,n) = 1 Definition 3. A signed Gauss word w is a data word over the alphabet Σ × N where Σ = {U + , O+ , U − , O− }, such that for every n either

510

A. Lisitsa, I. Potapov, and R. Saleh

– |w|(U + ,n) = |w|(O+ ,n) = |w|(U − ,n) = |w|(O− ,n) = 0, or – |w|(U + ,n) = |w|(O+ ,n) = 1 and |w|(U − ,n) = |w|(O− ,n) = 0, or – |w|(U − ,n) = |w|(O− ,n) = 1 and |w|(U + ,n) = |w|(O+ ,n) = 0, Definition 4. A shadow Gauss word w is a word over alphabet N (i.e. finite sequence of natural numbers) such that for every n ∈ N either |w|n = 0 or |w|n = 2 Shadow Gauss words can be seen as the projections of (un)signed Gauss words on the second components of their symbols. A (unsigned, signed, shadow) Gauss language is an arbitrary set of (unsigned, signed, shadow) Gauss words. We denote the data language of all unsigned Gauss words by LGW and the language of all signed Gauss words by LSGW . Proposition 1. The languages LGW and LSGW are recognisable by deterministic 2-way register automata. Proof. We explain only the construction of a 2-way deterministic register automaton A which recognises LGW . With obvious modifications the automaton can be adapted to the case of LSGW . Let w be a data word (a1 , b1 )...(an , bn ) such that a ∈ Σ = {U, O} and b ∈ N = {1, ..., n}. The automaton A reads the first symbol (ai , bi ) and stores the value of bi in some register, then it moves right then left along the word to compare the current symbol (aj , bj ) with the value of bi held in some register. If the symbol (aj , bj ) where bi = bj and ai = aj is found and there are no further occurrences of bi then automaton A moves right along the word and checks next symbol. If next symbol is equal to end symbol then A moves to an accepting state. Proposition 2. The languages LGW and LSGW are not recognisable by nondeterministic one-way register automata. Proof. We show the argument only for the case of LGW . With obvious modifications it works for LSGW as well. The argument is not new and was used e.g. in [12] to show non-recognizability of some data languages by one-way register automata. Assume that language L is recognisable by some one-way register automaton A with n registers. Consider the word w = (U, 1)(U, 2) . . . (U, n + 1)(O, 1)(O, 2) . . . (O, n + 1) ∈ L. The automaton A accepts this word. After

Fig. 1. Example of a knot diagram with its corresponding Gauss words(signed and unsigned)

Automata on Gauss Words

511

Fig. 2. Example of a virtual knot

reading first n + 1 positions there is at least one index value i ∈ {1, . . . , n + 1} which does not appear in any register of R. That means that automaton A also accepts a word w ∈ L which obtained from w by replacing (U, i) with (U, i + 1). That is in contradiction with an assumption on A. 3.2

Planar and Non-planar Gauss Words

Every knot can be represented by a Gauss word but not every Gauss word represents a knot. For example, any attempt to reconstruct a knot diagram from the Gauss word O1− O2− U1− O3+ U2− U3+ will lead to new (virtual ) crossings which are not present in the Gauss word (see Figure 2). Such an observation was one of the motivations for introducing virtual knot theory [13]. The Gauss word which represents a classical knot diagram, that is a diagram embeddable into a plane without virtual crossings, is called classical or planar. The problem of recognition of planar Gauss words have been formulated by Gauss himself and recently several algorithmic solutions for both signed and unsigned case have been proposed, e.g. in [14,15,13,8]. In this section we address the question of recognisability of planarity of Gauss words by automata models and consider unsigned and signed case separately. Signed Gauss Words. In this subsection we will show that a language of planar signed Gauss words can be recognised by two-way deterministic register automata. The design of automata will be based on a linear time algorithm, presented by V. Kurlin in [8]. The main idea of the algorithm is computing the least genus of the surface to which a knot diagram is embeddable without virtual crossings. For this purpose the Euler characteristics χ of the combinatorial cell complex (Carter surface) [16] associated with the knot diagram is computed. Computation of the Euler characteristics χ requires counting the number of faces (cycles), edges and vertices of a combinatorial cell complex (Carter surface) associated with a knot diagram. In the context of Gauss word, the number of edges corresponds to the length of the word, the number of vertices corresponds to the number of crossings (that is half the length of the word) and the number of faces can be determined by implementing a set of traversal rules. Lemma 2. Two-way deterministic register automaton can traverse all faces of (a complex associated with) a knot diagram which are adjacent to a crossing i.

512

A. Lisitsa, I. Potapov, and R. Saleh

+

−

Fig. 3. Automaton moves

Proof. The traversal of adjacent face to a crossing i in the knot diagram can be done by choosing initial direction and turning left on each consecutive visited crossing staring from i. This global property of “turning left” can be defined by deterministic set of traversal rules which will take into account only local property of the current crossing and a finite information about previously visited one. In general we have 8 cases since there are two types of crossings (with a sign “+” and with a sign “-”) and four directions from which we can approach each crossing, see Figure 3. We follow interpretation of the local rules for selecting cycles defined in [8], but present them here in slightly different notation, which is more appropriate for the design of a register automaton. A register automaton that is observing a current symbol S, needs to choose a correct symbol which correspond to the next crossing after turning (geometrically) to the left on a knot diagram. In fact on the Gauss code it will correspond to finding S  which is the counterpart of S and then choosing a symbol which is either left or a right neighbour of S  . For example, if S is Oi (Ui ) then we need to choose a neighbour of Ui (Oi ) in the Gauss word. In order to define whether we need a symbol from the left or from the right side we need to know the current type of the crossing which is S and the information about the previous choice of direction, i.e. whether S was chosen as a left or a right symbol. Now we define eight rules in the form (D, S) → (S  , D ) where D, D ∈ {Right, Lef t} and S, S  ∈ {U, O}×N×{+, −} where N ∈{1,2. . . ,n}. Each rule can be read as follows: if the current symbol S is reached via direction D then find S  (counterpart of S) and move one step to the specified direction. (Right, Oi + )→ (Ui + , Right) (Left, Oi + )→ (Ui + , Left) (Right, Ui − )→ (Oi − , Right) (Left, Ui − )→ (Oi − , Left)

(Right, Ui + )→ (Oi + , Left) (Left, Ui + )→ (Oi + , Right) (Right, Oi − )→ (Ui − , Left) (Left, Oi − )→ (Ui − , Right)

Following above rules we can design a register automata that will keep the finite information about its previous choice of direction (Right or Left) in its state space and which will choose the Right or Left symbol of S  observing the symbol S. It can also keep records on which rule was applied to the starting symbol S and will terminate the traversal of a face if the same rule will be applied for S again. The fact of the repetition corresponds to the completion of a cyclic path. In order to traverse all faces which are adjacent to a crossing i we need to start from two different initial conditions associated with labels (Oi or Ui ) and two different initial direction (Left or Right).  

Automata on Gauss Words

513

Lemma 3. Two-way register automata with k registers on the input with t distinct symbols can simulate a counter machine with k counters bounded by t. Proof. Let us assume that a word on an input tape has at least t distinct symbols. The value of a counter stored in register i corresponds to the number of distinct symbols from the beginning of the word till the position of the first appearance of symbol stored in the register. Then we can increase (decrease) the value by looking for the next (previous) symbol on the string that will appear for the first time. Counter i is equal to zero if the value stored in the register i is the first symbol on the input tape. If we use k registers then we can store k counters bounded by t, where t is a number of distinct symbols on the input tape.   Lemma 4. Two-way deterministic register automata can compute the Euler characteristics of a signed Gauss word. Proof. In order to compute Euler characteristics we need to count the number of faces in a degree 4 graph G represented by a signed Gauss word, the number of edges and the number of vertices in G. The number of vertices in G is a number of distinct symbols, and the number of edges is the number of symbols in the Gauss word. Both values can be counted in a straightforward way. The number of faces can be counted by traversal of G in the following way. The automaton goes sequentially through the list of vertices. For each vertex i it traverses (as described in Lemma 2) all adjacent faces and increases a counter by one for every face F in which there are no vertices of smaller than i labels. Also the automaton counts how many times a crossing i is met during the traversal of faces adjacent to i. As soon as the value reaches 4 the automaton starts the traversal for the next crossing. The computation of the Euler characteristics χ is done by counting the values for edges, vertices and faces in individual counters and then by subtracting number of edges from the sum of the numbers of vertices and faces. Since the number of each value in counters is bounded by the number of distinct symbols the computation can be done by the two-way deterministic register automaton.   Theorem 1. A language of planar signed Gauss words can be recognised by two-way deterministic register automata. Proof. Compute the Euler characteristics by the two-way deterministic register automaton. If the Euler characteristics χ is equal to 2 then a signed Gauss word is planar [16,8].   Unsigned Gauss Words. As for signed words, an unsigned Gauss word w is called planar if there is a knot diagram such that w is a Gauss word read off this diagram. Before discussing the recognisability of this property by automata we briefly present an algorithm for recognition of planar unsigned Gauss word proposed by L. Kauffman in [13]. In fact, planarity here does not depend on first components of Gauss data words, i.e. on information whether particular crossing is under- or over-crossing. Because of that the input for the algorithm is

514

A. Lisitsa, I. Potapov, and R. Saleh

Fig. 4. Not dually paired word and the corresponding graph

a shadow Gauss word, i.e a sequence of labels (=natural numbers), where each label in the sequence occurs twice. We assume the labels in the input word w are 1, 2, . . . , n and they first occur in w in that order. The algorithm proceeds in three stages: 1. The input word is checked on whether there is even number of labels in between two appearances of any label. If ”yes” the algorithm proceeds to the second stage, if ”no” the algorithm stops with the result ”no, the input word is non-planar”. 2. Starting with i = 1, the order of labels occurrence between two occurrences of i is reversed. The process is repeated successively using i = 1, 2, . . . , n. Let w∗ is a resulting word. 3. w∗ is checked on whether it is a dually paired word. If ”yes” the algorithm stops with the result ”yes, the input word is planar”. If ”no” the algorithm stops with the result ”no, the input word is non-planar”. To complete the algorithm description we explain what is a dually paired word [13]. Definition 5. For a shadow Gauss word w two labels i and j are called interlaced in w iff w = w1 i w2 j w3 i w3 j w4 or w = w1 j w2 i w3 j w3 i w4 . Definition 6. A shadow Gauss word w is called dually paired iff the set of all labels of w can be partitioned into two subsets such that no two labels in the same subset are interlaced. An example of the shadow word which is not dually paired is shown in Figure 4(a). Returning to the question on lower and upper bounds for the planarity of unsigned Gauss words problem one may notice that the first stage of the Kauffman algorithm is obviously implementable on the deterministic register automata. The second stage looks problematic, for to implement reversing the finite memory appears to be insufficient. We do not have a proof though, neither we know a better method to check planarity, so we propose the following Conjecture 1. Planarity of unsigned Gauss words is not recognisable by (non)deterministic register automata. The next proposition will be used later to show upper bound for planarity of unsigned Gauss words problem.

Automata on Gauss Words

515

Proposition 3. The shadow Gauss language of not dually paired words is recognisable by a non-deterministic two-ways register automaton. Proof. Given a shadow Gauss word w define an undirected graph gw as follows. The vertices of qw are labels in w and there is an edge (i, j) in gw iff i and j are interlaced. Figure 4(b) demonstrates the graph gw for the word w shown in Figure 4(a). Now it is straightforward to verify that w is dually paired iff gw is a bipartite graph. The graph is bipartite iff it does not contain the cycle of the odd size. Required register automaton given a word w simulates non-deterministic traversal of the graph gw . At the beginning it picks up non-deterministically a vertex i of gw by moving its head to the first occurrence of the label i in w, stores the label i in the register and starts the traversal of the graph moving along the edges of gw . The parity of the length of the path is stored in the finite state control of the automaton. If during traversal the automaton arrives at the vertex stored in the register it checks the parity of the path covered so far and if it is odd the word is accepted.   We conjectured earlier that planarity of unsigned Gauss words is not recognisable by register automata. In order to get an upper bound one may try to extend the register automata with pebbles. However as the following proposition shows over Gauss words register automata are capable to model effects of adding any finite number of pebbles. Proposition 4. If an n-bounded language over infinite alphabet A can be recognised by a k-pebble automaton, then it is also recognised by a k-register automaton. Proof. Assume that we have to place a pebble on the symbol x ∈ A from the word u · x · v, u, v ∈ A∗ . The position of this pebble can be uniquely represented by a pair (x, lx ), where x is a symbol with a pebble and lx = |u|x , i.e. the number of occurrences of a symbol x in a word u. Thus, in order to simulate a pebble we need one register (for storing x) and a finite number of states (for keeping lx in a state space) since lx is bounded by a constant n. To simulate LIFO stack discipline by the register automaton one may use resister i to store a symbol which has a pebble i placed on it and the finite state structure of the automaton to store a reference to the register which corresponds to the current top of the stack.   Theorem 2. Planarity of unsigned Gauss words is recognisable by deterministic linearly bounded memory automata Proof. The proof consists in showing that the Kauffman algorithm is implementable on LBMA. Indeed, the first stage of the algorithm is implementable with the finite memory. Also, it is straightforward to implement the second stage (reversing) on the linear memory. Proposition 3 states that the third stage of the algorithm, that is the search for the cycles of odd size on the graph associated with the Gauss word, can be done non-deterministically using only the finite memory. Notice,

516

A. Lisitsa, I. Potapov, and R. Saleh

that if the cycle of odd size exists in the graph, then necessarily the odd cycle of the size no more than n also exists, where n is the length of the input word. Deterministic automaton may iterate then over all paths of the length up to n and check the odd cycle condition. The linear order on the input Gauss word induces the linear order on the vertices of the associated graph. It is clear that this order as well as the relation ”next” with respect to the order are computable using only finitely many registers. The linear order on vertices is extended lexicoraphically on paths in the graph. Deterministic automaton iterates over paths along this order. No more than O(n) memory is needed.  

4

Conclusion

We have applied automata over infinite alphabets for studying complexity of problems related to knots. We have shown that the language of the signed Gauss words can be recognized by deterministic two-way register automata, while for the same problem for unsigned words we demonstrated an upper bound in terms of automata with linearly bounded memory. The obvious next step is to try to establish a lower and better upper bound for the latter problem. More generally, automata based approach opens new perspectives for studying more complex knot problems, like unknotedness or equivalence. Non-trivial lower bounds for such problems are unknown and weak automata models are plausible candidates here to try. In opposite direction, knot theory provides a reach supply of natural problems formulated in terms of languages over infinite alphabets, and that, one may expect, will influence the development of the theory of such languages and related computational models.

References 1. Kari, J., Niemi, V.: Morphic Images of Gauss Codes. In: Developments in Language Theory, pp. 144–156 (1993) 2. Abramsky, S.: Temperley-Lieb Algebra: From Knot Theory to Logic and Computation via Quantum Mechanics. Mathematics of Quantum Computation and Quantum Technology (2007) 3. Freivalds, R.: Knot Theory, Jones Polynomial and Quantum Computing. In: Jedrzejowicz, J., Szepietowski, A. (eds.) MFCS 2005. LNCS, vol. 3618, pp. 15–25. Springer, Heidelberg (2005) 4. Lomonaco Jr., S., Kauffman, L.: Topological Quantum Computing and the Jones Polynomial. Arxiv Preprint Quant-ph/ 0605004 (2006) 5. Hass, J., Lagarias, J., Pippenger, N.: The computational complexity of knot and link problems. Journal of the ACM (JACM) 46(2), 185–211 (1999) 6. Kaminski, M., Francez, N.: Finite-memory automata. In: Proceedings of 31st Annual Symposium on Foundations of Computer Science, pp. 683–688 (1990) 7. Neven, F., Schwentick, T., Vianu, V.: Finite state machines for strings over infinite alphabets. ACM Transactions on Computational Logic (TOCL) 5(3), 403–435 (2004) 8. Kurlin, V.: Gauss phrases realizable by classical links. Arxiv Preprint Math. GT/ 0610929 (2006)

Automata on Gauss Words

517

9. David, C.: Mots et donn´ees infinies. Master’s thesis, LIAFA (2004) 10. Demri, S., Lazic, R.: LTL with the freeze quantifier and register automata. In: LICS, vol. 6, pp. 17–26 (2006) 11. Milo, T., Suciu, D., Vianu, V.: Typechecking for XML transformers. Journal of Computer and System Sciences 66(1), 66–97 (2003) 12. Bjorklund, H., Schwentick, T.: On Notions of Regularity for Data Languages. In: ´ Csuhaj-Varj´ u, E., Esik, Z. (eds.) FCT 2007. LNCS, vol. 4639, pp. 88–99. Springer, Heidelberg (2007) 13. Kauffman, L.: Virtual knot theory. Arxiv Preprint Math. GT/ 9811028 (1998) 14. Cairns, G., Elton, D.: The planarity problem for signed Gauss words. Journal of Knot Theory and its Ramifications 2(4), 359–367 (1993) 15. Cairns, G., Elton, D.: The Planarity Problem II. Journal of Knot Theory and its Ramifications 5, 137–144 (1996) 16. Carter, J.: Classifying immersed curves. Proc. Amer. Math. Soc. 111, 281–287 (1991)

Analysing Complexity in Classes of Unary Automatic Structures Jiamou Liu1 and Mia Minnes2 1

Department of Computer Science, University of Auckland, New Zealand [email protected] 2 Department of Mathematics, MIT, USA [email protected] Abstract. This paper addresses the time complexity of several queries (including membership and isomorphism) in classes of unary automatic structures and the state complexity of describing these classes. We focus on unary automatic equivalence relations, linear orders, trees, and graphs with finite degree. We prove that in various senses, the complexity of these classes is low: (1) For the isomorphism problem, we either greatly improve known algorithms (reducing highly exponential bounds to small polynomials) or answer open questions about the existence of a decision procedure; (2) for state complexity, we provide polynomial bounds with respect to natural measures of the sizes of the structures.

1

Introduction

A (relational) structure is automatic if its elements can be coded in a way such that the domain and all the relations of the structure are recognized by finite automata (precise definitions are in Section 2). Automatic structures form a large class of infinite structures with finite representations and effective semantics. In particular, for any automatic structure A and first-order query ϕ, one can effectively construct an automaton that recognizes all elements of A that satisfy ϕ. Such useful algorithmic and model-theoretical properties of automatic structures have led to extensive work in the area in recent years. The field of automatic structures can be viewed as an extension of finite model theory in which one studies the interaction between logical definability and computational complexity. As finite model theory has found applications in databases [1] automatic structures have been used in relational databases and computeraided verifications [2,3]. However, this approach has limitations. In particular, since the configuration space of a Turing machine can be coded by a finite automaton [4], reachability is undecidable for automatic structures in general. On the other hand, unary automatic structures, those recognized by automata over a unary alphabet, have decidable monadic second-order theories. Any automatic structure has an isomorphic copy over the binary alphabet [5]; the intermediate class of structures whose domain elements are encoded as finite strings over 1 2 reachability is no longer decidable because the grid can be coded. Much is known about the complexity of automatic structures. Algebraic characterizations have been given for automatic Boolean algebras [4] and finitely A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 518–529, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Analysing Complexity in Classes of Unary Automatic Structures

519

generated automatic groups [6]. Some of these results give information about computational content: the isomorphism problem of automatic Boolean algebras is decidable. However, the full class of automatic structures has significant underlying complexity. From a computability theoretic point of view, the isomorphism problem and the embedding problem for automatic structures are both Σ11 -complete [4,7]. Model theoretically, we also find richness: [8] shows that the Scott ranks of automatic structures can be as high as possible, up to the successor of the first non-computable ordinal. Finally, the resource-bounded complexity of automatic structures has been studied. For a fixed automaton, the complexity of model-checking for quantifier-free formulas is LOGSPACE-complete and for existential formulas it is NPTIME-complete [9]. On the other hand, there are automatic structures whose first-order theories are nonelementary [10]. In this paper we consider classes of unary automatic structures and show they are simple with respect to two notions of complexity. First, we study the time complexity of natural decision problems in a fixed class K of structures. The membership problem asks, given a unary automatic presentation of A, decide if A ∈ K. The isomorphism problem asks, given unary automatic presentations of A and B from K, decide if A ∼ = B. For each class of unary automatic structures we consider, we give low polynomial time solutions to its membership problem. For unary automatic equivalence relations, linear orders, and trees we solve the isomorphism problem in low polynomial time; the isomorphism problem for graphs with finite degree is decidable with elementary time bound. State complexity measures the descriptive complexity of regular languages, context-free grammars, and other classes of languages with finite representations. The state complexity of a regular language L is defined as the size of the smallest automaton recognizing L. It has been studied since the 1950s [11,12,13] and motivated, in part, by the relationship between the runtime of realtime computations running on automata and the size of their state space. We generalize state complexity to structures (rather than sets): the state complexity of an automatic structure A is defined to be the number of states in an optimal automaton presentation of a structure isomorphic to A. For unary automatic structures, we require that the presentation witnessing the state complexity also be a unary automatic structure. We prove that the state complexity of unary automatic equivalence relations, linear orders, and trees are each polynomial with respect to a natural representation of the structures. The study of state complexity of automatic structures which we hope will continue to be fruitful. Paper organization. Section 2 introduces the terminology and notation used throughout the paper. In particular, it recalls the definitions of automatic structures and unary automatic structures and makes precise the definition of state complexity for unary automatic structures. Sections 3, 4, 5 and 6 discuss linear orders, equivalence relations, trees and graphs of finite degree (respectively). Due to space considerations, this paper is an extended abstract and so we omit many proofs.

520

2

J. Liu and M. Minnes

Preliminaries

We assume the basic terminology and notation from automata theory (see [14] for example). For a fixed alphabet Σ, a finite automaton is a tuple A = (S, Δ, ι, F ) where S, Δ, ι, F are (respectively) the state space, transition function, initial state, and accepting states. In particular, if A is a finite automaton over the unary alphabet {1} it is called a unary automaton. We use synchronous n-tape automata to recognize n-ary relations. Such automata have n input tapes, each of which contains one of the input words. Bits of the n input words are read in parallel until all input strings have been completely processed. Formally, let Σ = Σ ∪ {} where  is a symbol not in Σ. Given an n-tuple of words w1 , w2 , . . . , wn ∈ Σ  , we convert them to a word over the alphabet (Σ )n with length max{|w1 |, . . . , |wn |} whose k th symbol (σ1 , . . . , σn ) where σi is the k th symbol of wi if k ≤ |wi |, and is  otherwise. An n-ary relation R is FA recognizable if the set of words obtained in this way is a regular subset of (Σn ) . A relational structure S consists of a countable domain D and atomic relations on D. A structure is called automatic over Σ if it is isomorphic to a structure whose domain is a regular subset of Σ  and each of whose atomic relations is FA recognizable. A structure is called unary automatic if it is automatic over the alphabet {1}. The structures (N; s) and (N; ≤) are both unary automatic structures. On the other hand, (Q; ≤) and (N; +) are automatic over {0, 1} but are not unary automatic. The structure (N; ×) is not automatic over any finite alphabet. For proofs of these facts, see the survey papers [15,16]. Consider F O +∃∞ +∃k,l , the first-order logic extended by quantifiers for there exist infinitely many and there exist k many mod l (k, l ∈ N). The following theorem from [9,17,18,5] connects this extended logic with automata. Theorem 1. For an automatic structure, A, there is an algorithm that, given a formula ϕ(¯ x) in F O + ∃∞ + ∃k,l , produces an automaton whose language is those tuples a ¯ from A that make ϕ true. We study automatic structures (D; R) where R is a binary relation over D. Theorem 1 can be used to give decision procedures for some properties of binary relations. Table 1 lists the complexity of the associated algorithms if AD (m states) and AR (n states) are deterministic FA recognizing D and R, respectively. Note that if (D; R) is automatic over Σ and D = Σ  , then m = 1. We use x to denote the string 1x and N for the set of all such strings {1}∗ . In [19], Blumensath shows that a structure is unary automatic if and only if it is Table 1. Deciding properties of binary relations in automatic structures Property First-order definition Time complexity Reflexivity ∀x (R(x, x)) O(mn) Symmetry ∀x, y (R(x, y) =⇒ R(y, x)) O(n2 ) Antisymmetry ∀x, y (R(x, y) ∧ R(y, x) =⇒ x = y) O(n2 ) Totality ∀x, y (R(x, y) ∨ R(y, x)) O(m2 n2 ) Transitivity ∀x, y, z (R(x, y) ∧ R(y, z) =⇒ R(x, z)) O(n3 )

Analysing Complexity in Classes of Unary Automatic Structures

521

first-order interpretable in U = (N; 0, 1 ), where s is the successor relation and modj (x, y) holds if and only if x ≡ y mod j, and therefore proves the following. Theorem 2. The monadic second order (MSO) theory of a unary automatic structure is decidable. We need to understand the structure of regular subsets and relations of {1} . Lemma 1 ([19]). A set L ⊆ N is unary automatic if and only if there are tL , L ∈ N such that L = L1 ∪ L2 with L1 ⊆ {0, 1, . . . , tL − 1} and L2 is a finite union of sets in the form {j + iL}i∈N where tL ≤ j < tL + L . A 2-tape unary automaton may be described as follows.States reachable from the initial state by reading inputs of type (1, 1) are called (1, 1)-states and form a disjoint union of a tail and a loop. We label the (1, 1)-tail states as q0 , . . . , qt−1 ; the (1, 1)-loop states as qt , . . . , qt+−1 . States reachable from a (1, 1)-state by reading inputs of type (1, ) are called (1, )-states. The set of (1, )-states reachable from any given qi consist of a tail and a loop, called the (1, )-tail and loop from qi ; the (, 1)-tails and loops are defined similarly. Khoussainov and Rubin [20] and Blumensath [19] gave a characterization of all unary automatic binary relations on N. Let B = (B, EB ) and D = (D, ED ) be finite graphs. Let R1 , R2 be subsets of D × B, and R3 , R4 be subsets of B × B. Consider the graph D followed by countably infinitely many copies of B, ordered ¯ as follows. Its as B 0 , B 1 , B 2 , . . .. We define the infinite graph unwind(B, D, R) 0 1 2 vertex set is D ∪ B ∪ B ∪ B ∪ . . . and its edge set contains ED ∪ E 0 ∪ E 1 ∪ . . . as well as the following edges, for all a, b ∈ B, d ∈ D, and i, j ∈ ω: – (d, b0 ) when (d, b) ∈ R1 , and (d, bi+1 ) when (d, b) ∈ R2 , – (ai , bi+1 ) when (a, b) ∈ R3 , and (ai , bi+2+j ) when (a, b) ∈ R4 . Theorem 3 ([19,20]). A graph is unary automatic if and only if it is isomor¯ for some parameters B, D, R. ¯ phic to unwind(B, D, R) The state complexity of a regular language L is the number of states of the minimal deterministic finite automaton that recognizes L [12]. Definition 1. The state complexity of an (unary) automatic structure A is the size of the smallest (unary) automaton M (optimal automaton) such that M recognizes a structure B ∼ = A. If K is a class of automatic structures with associated finite isomorphism invariant RA , the state complexity of K is f such that for A ∈ K, if |RA | ≤ n, the state complexity of A is less than f (n). Note that this is a worst-case complexity measure: if a class of structures has state complexity f , there may still be a particular member of the class whose state complexity is much smaller. We look at the state complexity of three classes of unary automatic structures: equivalence relations, linear orders, and trees. We define natural isomorphism invariants for each class and show that the state complexity for each class is polynomial with respect to these invariants.

522

J. Liu and M. Minnes

In the sequel, we make the following assumptions without loss of generality. All structures are infinite with domain N. All automata are deterministic. Algorithms on unary automatic structures (N; R) have as input a synchronous 2-tape automaton recognizing R. The size of the input is the size of this input automaton. The sets of (1,1)-, (, 1)-, and (1, )- states are pairwise disjoint.

3

Linear Orders

A linear order is L = (N; ≤L ) where ≤L is total, reflexive, antisymmetric, and transitive. Table 1 immediately gives that the membership problem for automatic linear orders is decidable in time O(n3 ). Blumensath [19] and Khoussainov and Rubin [20] characterized unary automatic linear orders. We use ω, ω ∗ , ζ, and n to denote the order types of the positive integers, the negative integers, the integers, and the finite linear order of length n (respectively). Theorem 4 ([19,20]). A linear order is unary automatic if and only if it is isomorphic to a finite sum of linear orders of type ω, ω ∗ or n. Corollary 1. The isomorphism problem for unary automatic linear orders is decidable. This corollary is proved by defining, for each unary automatic linear order L, a sentence ϕL such that for any L , L ∼ = L if and only if L  ϕL ; this yields a triply exponential decision procedure. We improve this bound, giving a quadratic time algorithm for the isomorphism problem for unary automatic linear orders. 3.1

Efficient Solution to the Isomorphism Problem

Theorem 5. The isomorphism problem for unary automatic linear orders is decidable in quadratic time in the sizes of the input automata. We use the notation from Section 2: given a unary automaton A it has parameters t,  which are the lengths of its (1, 1)-tail and -loop. Lemma 2. Suppose A is a unary automaton that represents a linear order L = (N; ≤L ). For any t ≤ j < , the sequence (j + i)i∈N is either an increasing chain in a copy of ω in L or a decreasing chain in a copy of ω ∗ in L. Proof (of Theorem 5). Suppose L = (N; 0 is 12 (kL + kL ); with mL > 0, kL = 0 is 2m2L + mL ; and 2 – with mL > 0, kL > 0 is kL + 2m2L + 2mL kL + mL .

Proof. Lemma 2 implies the optimal automaton has mL + kL (1, 1)-states.



Corollary 2. The (unary) state complexity for the class of unary automatic linear orders is quadratic in the size of the associated parameter, |αL |.

4

Equivalence Relations

A structure E = (N; E) is an equivalence structure if E is an equivalence relation (reflexive, symmetric, and transitive). Table 1 immediately gives that the membership problem for automatic equivalence structures is decidable in time O(n3 ). Blumensath [19] and Khoussainov and Rubin [20] classified unary automatic equivalence structures. Theorem 7 ([19,20]). An equivalence structure has a unary automatic presentation if and only if it has finitely many infinite equivalence classes and there is a finite bound on the sizes of the finite equivalence classes. The height of an equivalence structure E is a function hE : N ∪ {∞} → N ∪ {∞} where hE (x) is the number of E-equivalence classes of size x. Two equivalence structures E1 and E2 are isomorphic if and only if hE1 = hE2 . By Theorem 7, if E is unary automatic then hE is finitely nonzero. Corollary 3. The isomorphism problem for unary automatic equivalence structures is decidable. We may define an extended first order sentence which describes the height function hE and leads to doubly exponential runtime for deciding whether two

524

J. Liu and M. Minnes

equivalence structures are isomorphic. We significantly improve this bound by giving a quadratic time algorithm for the isomorphism problem. 4.1

Efficient Solution to the Isomorphism Problem

Theorem 8. The isomorphism problem for unary automatic equivalence structures is decidable in quadratic time in the sizes of the input automata. Proof. Suppose E is recognized by a unary automaton A with n states. Recall the definitions of t, , and qj from Section 2. Observe that each j < t +  belongs to an infinite equivalence class if and only if there is an accepting state on the (, 1) loop from qj . Let t ≤ j < t + . If j belongs to an infinite equivalence class then the set {j + i}i∈N is partitioned into c infinite equivalence classes for some c > 0. It takes O(n2 ) time to compute the total number of infinite equivalence classes. Each 0 ≤ j < t +  such that qj has no accepting state on its (, 1)-loop may be responsible for infinitely many finite equivalence classes of the same size and finitely many other equivalence classes. We can find all k such that hE (k) = ∞ in O(n) time. It remains to compute the sizes of equivalence classes for elements represented on the (1, 1)-loop but such that hE (k) < ∞. This can be done by reading through the (, 1)-tails off the (1, 1)-tail and has 

runtime O(n). This algorithm takes O(n2 ). 4.2

State Complexity

The height function hE is a finite isomorphism invariant for unary automatic equivalence structures. We will express the state  complexity in terms of the height function hE ; let hinf = hE (∞) and ninf = n:hE (n)=∞ n. Define ⎛ |hE | = ⎝

⎞



nhE ⎠ + ninf + hinf .

n 0 such that for any n > N , ρ(n) ≥ (α − ε)n, where α = 1+3√5 ≈ 0.927. Although it was conjectured in [10] that this bound is optimal, a new bound was shown in [11], improving the lower bound to α = 174719/184973 ≈ 0.944565. The bound was obtained by considering the runs of an infinite series of strings w, w2 , w3 , . . ., based on a run-rich string w. To the best of our knowledge, the current best lower bound is α = 27578248/29196442 ≈ 0.9445756438404378 achieved by a run-rich string discovered by Simon Puglisi and Jamie Simpson2 . In this paper, we design a new series of run-rich strings defined by a simple recurrence formula, and improve the bound further to 0.94457567. We give a 1 2

Presented on the website http://www.csd.uwo.ca/faculty/ilie/runs.html Personal communication.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 578–587, 2009. c Springer-Verlag Berlin Heidelberg 2009 

A Series of Run-Rich Strings

579

conjecture for the exact number of runs contained in each string of the series, and show that the series improves the bound further to α ≈ 0.94457571235.

2

Preliminaries

Let Σ be a finite set of symbols, called an alphabet. Strings x, y and z are said to be a prefix, substring, and suffix of the string w = xyz, respectively. The length of a string w is denoted by |w|. The i-th symbol of a string w is denoted by w[i] for 1 ≤ i ≤ |w|, and the substring of w that begins at position i and ends at position j is denoted by w[i : j] for 1 ≤ i ≤ j ≤ |w|. A string w has period p if w[i] = w[i + p] for 1 ≤ i ≤ |w| − p. A string w is called primitive if w cannot be written as uk , where k is a positive integer, k ≥ 2. A string u is a run if it is periodic with (minimum) period p ≤ |u|/2. A substring u = w[i : j] of w is a run in w if it is a run of period p and neither w[i − 1 : j] nor w[i : j + 1] is a run of period p, that means the run is maximal. We denote the run u = w[i : j] in w by the triple i, j −i+1, p consisting of the begin position i, the length |u|, and the minimum period p of u. For a string w, we denote by run(w) the number of runs in w. For example, the string aabaabaaaacaacac contains the following 7 runs: 1, 2, 1 = a2 , 4, 2, 1 = a2 , 7, 4, 1 = a4 , 12, 2, 1 = a2 , 13, 4, 2 = (ac)2 , 8 7 1, 8, 3 = (aab) 3 , and 9, 7, 3 = (aac) 3 . Thus run(aabaabaaaacaacac) = 7. We are interested in the behavior of the maxrun function defined for all n > 0 by ρ(n) = max{run(w) | w is a string of length n}. Franˇek, Simpson and Smyth [10] showed a beautiful construction of a series of strings which contain many runs, and later Franˇek and Qian Yang [9] formally proved a family of true asymptotic lower bounds arbitrarily close to 1+3√5 n as follows. Theorem  1 ([9]).  For any ε > 0 there exists a positive integer N so that 3√ ρ(n) ≥ 1+ 5 − ε n for any n ≥ N .

3

A New Series of Run-Rich Strings

In this section, we show a construction of a series of run-rich binary strings, and we give new lower bound of the number of runs in string. The series {tn } of strings is defined by t0 = 0110101101001011010, t1 = 0110101101001, t2 = 011010110100101101011010,  tk−1 tk−2 (if k mod 3 = 0), tk = tk−1 tk−4 (otherwise), for any integer k > 2.

(1)

580

W. Matsubara et al.

Table 1 shows the length of {tn } and the number of runs in {tn } for i = 0, 1, . . . , 44. We actually counted the number of runs by implementing the lineartime algorithm proposed by Kolpakov and Kucherov [1] combined with the space-effiecient algorithm to compute Lempel Ziv Factorization proposed by Crochemore et al. [12]. In our PC with 18GB RAM, t44 was the longest possible string to be handled. As we can see, these strings contain many runs and the ratio run(tn )/|tn | in the third column is monotonically increasing as n grows. We are interested in its limit value, and we will try to estimate it in Section 4. Using this result in Table 1, we improve the bound. {tn } contains enough runs, but we can improve the bound further by considering the string tkn . First, we give a previous result about the number of runs in an infinite string obtained by concatenating the same string infinite many times. Theorem 2 ([11]). For any string w and any ε > 0, there exists a positive integer N such that for any n ≥ N , run(w3 ) − run(w2 ) ρ(n) > − ε. n |w| From Theorem 2, we show a new lower bound. Theorem 3. For any ε > 0 there exists a positive integer N so that ρ(n) > (α − ε) n for any n ≥ N , where α = 48396453 51236184 ≈ 0.94457567. Proof. From Table 1, we have |t41 | = 51236184, run(t41 ) = 48396417, run(t241 ) = 96792871, and run(t341 ) = 145189324. Therefore from Theorem 2, we have 145189324 − 96792871 ρ(n) > − ε. n 51236184

 

Needless to say this bound is not optimal. If we can calculate run(tn ) for larger n, we would be able to obtain better bounds.

4

Analysis of Asymptotic Behavior

In this section, we analyze the asymptotic behavior of the number of runs in {tn }. We conjecture that limn→∞ run(tn )/|tn | ≈ 0.94457571235. To make the analysis easier, we classify the strings of {tn } into the following three forms and we focus attention on {an }. an = t3m = bn−1 cn−1 , bn = t3m+1 = an an−1 , cn = t3m+2 = bn bn−1 .

A Series of Run-Rich Strings Table 1. The length of {tn } and number of runs in {tn } n 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

|tn | 19 13 24 37 56 69 125 162 218 380 505 667 1172 1552 2057 3609 4781 6333 11114 14723 19504 34227 45341 60064 105405 139632 184973 324605 430010 569642 999652 1324257 1754267 3078524 4078176 5402433 9480609 12559133 16637309 29196442 38677051 51236184 89913235 119109677 157786728

run(tn ) 13 7 17 28 47 56 110 143 197 346 467 617 1094 1451 1930 3391 4501 5964 10480 13887 18405 32307 42808 56712 99540 131868 174698 306586 406152 538042 944219 1250831 1657010 2907866 3852116 5102974 8955120 11863017 15715165 27578212 36533368 48396417 84929820 112508068 149041473

run(tn )/|tn | 0.6842105263 0.5384615385 0.7083333333 0.7567567568 0.8392857143 0.8115942029 0.8800000000 0.8827160494 0.9036697248 0.9105263158 0.9247524752 0.9250374813 0.9334470990 0.9349226804 0.9382596014 0.9395954558 0.9414348463 0.9417337755 0.9429548317 0.9432180941 0.9436525841 0.9439039355 0.9441344479 0.9441928609 0.9443574783 0.9443966999 0.9444513524 0.9444894564 0.9445175694 0.9445265623 0.9445477026 0.9445530588 0.9445597506 0.9445649928 0.9445683560 0.9445696041 0.9445722316 0.9445729255 0.9445737288 0.9445744108 0.9445748074 0.9445749707 0.9445752897 0.9445753765 0.9445754715

run(t2n ) 29 19 39 62 99 120 227 295 402 704 943 1246 2200 2916 3872 6799 9016 11945 20977 27793 36827 64636 85635 113446 199102 263760 349418 613199 812328 1076111 1888465 2501691 3314047 5815764 7704261 10205980 17910272 23726068 31430362 55156461 73066770 96792871 N/A N/A N/A

run(t3n ) 44 30 60 95 150 183 343 446 606 1061 1418 1874 3305 4380 5813 10206 13530 17925 31473 41698 55248 96964 128461 170179 298663 395651 524137 919811 1218503 1614179 2832710 3752550 4971083 8723661 11556405 15308985 26865423 35589118 47145558 82734709 109600171 145189324 N/A N/A N/A

run(tkn )/k|tn | 0.7894736842 0.8461538462 0.8750000000 0.8918918919 0.9107142857 0.9130434783 0.9280000000 0.9320987654 0.9357798165 0.9394736842 0.9405940594 0.9415292354 0.9428327645 0.9432989691 0.9436071949 0.9440288168 0.9441539427 0.9442602242 0.9443944574 0.9444406711 0.9444729286 0.9445174862 0.9445314395 0.9445424880 0.9445567098 0.9445614186 0.9445648824 0.9445695538 0.9445710565 0.9445722050 0.9445737117 0.9445742027 0.9445745716 0.9445750626 0.9445752219 0.9445753423 0.9445755014 0.9445755531 0.9445755921 0.9445756438 0.9445756606 0.9445756733 N/A N/A N/A

581

582

W. Matsubara et al.

By definition, we can get the closed form of {an } as follows: an = bn−1 cn−1 = bn−1 bn−2 bn−1 = an−1 an−2 an−2 an−3 an−1 an−2 . So we will analyze the length of {a2n } in Section 4.1, and the number of runs in Section 4.2. 4.1

Length

At first we give the generating function of |a2n | = |t6n |. Lemma 1. Let LA (z) be the generating function of |a2n |. LA (z) can be represented as follows: −17z 2 + 65z − 19 . LA (z) = 3 z − 5z 2 + 10z − 1 Proof. |ak | = |ak−1 ak−2 ak−2 ak−3 ak−1 ak−2 | = 2|ak−1 | + 3|ak−2 | + |ak−3 |. Let gn = |an |, g0 = |a0 | = 19, g1 = |a1 | = 37, g2 = |a2 | = 125, gn = 2gn−1 + 3gn−2 + gn−3 ( n > 2 ). Therefore, we have general term of gn as follows: gn = 2gn−1 + 3gn−2 + gn−3 + 19[n=0] − 1[n=1] − 6[n=2] , where the expression m[n=k] means the function such that the result is m if n = k, and 0 if n = k. Let L(z) be the generating function of gn . We have    gn−1 z n + 3 gn−2 z n + gn−3 z n L(z) = 2 n

n

n

 + (19[n=0] − 1[n=1] − 6[n=2] )z n n

= 2zL(z) + 3z 2 L(z) + z 3 L(z) + 19 − z − 6z 2 6z 2 + z − 19 . = 3 z + 3z 2 + 2z − 1

A Series of Run-Rich Strings

583

By definition, |a2n | = |t6n | = |t3(2n) | = g2n ,  n

1 (L(z) + L(−z)) 2   1 6z 2 + z − 19 6z 2 − z − 19 = + 2 z 3 + 3z 2 + 2z − 1 −z 3 + 3z 2 − 2z − 1   1 −17z 4 + 65z 2 − 19 = . 2 z 6 − 5z 4 + 10z 2 − 1

g2n z 2n =

Therefore, the generating function of |a2n | is as follows:     1 −17z 2 + 65z − 19 LA (z) = |a2n |z n = g2n z n = . 2 z 3 − 5z 2 + 10z − 1 n n

 

To solve thisgenerating function, we use the following theorem. If A(z) is a power series k≥0 ak z k , we will find it convenient to write [z n ]A(z) = an . Theorem 4 (Rational Expansion Theorem for Distinct Roots [13]). If R(z) = P (z)/Q(z), where Q(z) = q0 (1 − ρ1 z) . . . (1 − ρ z) and the numbers (ρ1 , . . . , ρ ) are distinct, and if P (z) is a polynomial of degree less than , then [z n ]R(z) = a1 ρn1 + · · · + a ρn , where ak =

−ρk P (1/ρk ) . Q (1/ρk )

Using this theorem, we will show the general term of |an |. Let Q(z) = z 3 − 5z 2 + 10z − 1 and QR (z) = −z 3 + 10z 2 − 5z + 1. Therefore QR (z) is the “reflected” polynomial of Q(z). Let (α, β, γ) be the roots of QR (z). Therefore QR (z) = (z − α)(z − β)(z − γ), and Q(z) = (1 − αz)(1 − βz)(1 − γz). By Theorem 4, we have the general term of |an | as follows. x(19x2 −65x+17) Theorem 5. |an | = f (α)αn + f (β)β n + f (γ)γ n for f (x) = 10x2 −10x+3 , where (α, β, γ) are the roots of the equation −z 3 + 10z 2 − 5z + 1 = 0. The values of α, β, and γ are as follows:

√ √  10 1 3 1577 21 69 1 3 1  + − + 1577 + 21 69 , α= 3 3 2 2 3 2

√ √  3 1577 21 69 1  √  3 1 √  10 1  β= − 1−i 3 − − 1+i 3 1577 + 21 69 , 3 6 2 2 6 2

√ √  3 1577 21 69 1  √  3 1 √  10 1  − 1+i 3 − − 1−i 3 1577 + 21 69 . γ= 3 6 2 2 6 2

4.2

Number of Runs

Instead of trying to count the numbers of runs in the strings defined by the recurrence (1) only, we take a general approach here. We address ourselves to

584

W. Matsubara et al. Table 2. The length of {an } and number of runs in {an } n 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

|an | 19 37 125 380 1172 3609 11114 34227 105405 324605 999652 3078524 9480609 29196442 89913235

run(an ) 13 28 110 346 1094 3391 10480 32307 99540 306586 944219 2907866 8955120 27578212 84929820

Δn Δn − Δn−2

29 44 55 70 80 95 105 120 130 145 155 170

26 26 25 25 25 25 25 25 25 25

find general formulae which express the numbers of runs in strings defined by some recurrence, or equivalently, by some morphism. Let m, k, γ1 , γ2 . . . γk be integers such that 1 ≤ γj ≤ m for any 1 ≤ j ≤ k, and s0 , s1 , . . . , sm−1 ∈ Σ + be any nonempty strings. We consider a series of strings {sn } defined by the recurrence formula sn = sn−γ1 sn−γ2 . . . sn−γk

(n ≥ m).

 We pay our attentions to the quantity Δn = run(sn )− ki=1 run(sn−γi ). It is the difference between the number of newly created runs and the number of merged runs by the concatenation. Let p be the least common multiple of the two integers γ1 and γk . We observe that {Δn } is a mixture of p arithmetic progressions with the same common difference, except initial several terms. More formally, we have the following conjecture. Lemma 2 (Conjecture). There exist integers A and n0 such that Δn = Δn−p + A for any n ≥ n0 . For example, in {an } we have Δn = Δn−2 + 25 for n ≥ 5 (see Table 2). Unfortunately, we have not succeeded to give a formal proof to the conjecture at this time of writing. However, we have verified it for various instances and encountered no counter examples. Based on the conjecture, we have the following corollary, which is very useful to calculate the generating function. Corollary 1 (Based on conjecture Lemma 2). There exist integers A, B0 , . . . , Bp−1 , and n0 such that

A Series of Run-Rich Strings

run(spn+i ) =

k 

585

(run(spn+i−γj )) + An + Bi ,

j=1

for any n ≥ n0 . Note that an = an−1 an−2 an−2 an−3 an−1 an−2 , from Corollary 1, we have p = 2 and the recurrence formula of run(an ) for large n as follows: run(a2n ) = 2run(a2n−1 ) + 3run(a2n−2 ) + run(a2n−3 ) + 25n − 5, run(a2n+1 ) = 2run(a2n ) + 3run(a2n−1 ) + run(a2n−2 ) + 25n + 5. Let us consider the progression {rn } defined by r0 = 15, r1 = 27, r2 = 110, r2k = 2r2k−1 + 3r2k−2 + r2k−3 + 25k − 5 (k ≥ 2), r2k+1 = 2r2k + 3r2k−1 + r2k−2 + 25k + 5 (k ≥ 1). We can see that run(an ) = rn for any n ≥ 2. To analyze the asymptotic behavior of run(an ), we give the general term of {rn }. Let X(z), Y (z) be the generating functions of {r2n } and {r2n+1 }:  X(z) = r2n z n ,  Y (z) = r2n+1 z n . Then, X(z) = 2zY (z) + 3zX(z) + z 2 Y (z) +

25z 5z (1−z)2 − 1−z 25z 5z (1−z)2 + 1−z

−15 + 9z,

Y (z) = 2X(z) + 3zY (z) + zX(z) +

−3.

To solve above simultaneous equations, we have X(z) = −

19z 4 − 103z 2 + 164z 2 − 70z + 15 . (z − 1)2 (z 3 − 5z + 10z − 1)

Let α, β, γ are the roots of equation −z 3 + 10z 2 − 5z + 1 = 0. We have the general term r2n from X(z) as follows: r2n = g(α)αn + g(β)β n + g(γ)γ n + O(n) where,

 x 15x4 − 70x3 + 164x2 − 103x + 19 g(x) = . 12x4 − 52x3 + 6x2 − 28x + 5 Therefore we have the lower bounds of the maximal number of runs.

586

W. Matsubara et al.

Theorem 6 (Based on Conjecture Lemma 2) ρ(n) ≥ 0.94457571235. n Proof. run(a2n ) r2n = lim n→∞ |a2n | |a2n | g(α)αn + g(β)β n + g(γ)γ n + O(n) = lim n→∞ f (α)αn + f (β)β n + f (γ)γ n g(α)αn = (|α| > |β| = |γ|) f (α)αn α(15α4 −70α3 +164α2 −103α+19) 12α4 −52α3 +6α2 −28α+5 = α(19α2 −65α+17)

ρ(n) ≥ lim

n→∞

10α2 −10α+3

 3 − 10α + 10α2 99 − 488α + 889α2 = (17 − 65α + 19α2 ) (73 − 356α + 683α2 )

√ 3 −27669823+9298929 69 2 √ 7714 − 109145 3 −27669823+9298929 + 2 69 = 8079 ≈ 0.94457571235. 

5

 

Conclusion

In this paper, we showed a new series {tn } of run-rich strings defined by a simple recurrence formula, and we succeeded to improve the lower bound to 0.94457567 of the maximum number of runs in a string by using concrete string t41 . If we count the number of runs in a more longer strings t2n and t3n for n > 41, the bound can be improved further. Moreover, we gave a conjecture about the numbers of runs in the strings defined by any recurrence formula. Based on the conjecture, we evaluated the value lim run(tn )/|tn | accurately, which yields the best lower n→∞ bound so far. We are trying to give a proof of the conjecture. Recently, Baturo et al. [6] derived an explicit formula for the number of runs in any standard Sturmian words. Moreover, they showed how to compute the number of runs in a standard Sturmian words in linear time with respect to the size of its compressed representation, that is, the recurrences describing the string. We are interested in extending it to a general strings described by any recurrences for further research.

References 1. Kolpakov, R., Kucherov, G.: Finding maximal repetitions in a word in linear time. In: Proc. 40th Annual Symposium on Foundations of Computer Science (FOCS 1999), pp. 596–604 (1999)

A Series of Run-Rich Strings

587

2. Rytter, W.: The number of runs in a string: Improved analysis of the linear upper bound. In: Durand, B., Thomas, W. (eds.) STACS 2006. LNCS, vol. 3884, pp. 184–195. Springer, Heidelberg (2006) 3. Rytter, W.: The number of runs in a string. Inf. Comput. 205(9), 1459–1469 (2007) 4. Puglisi, S.J., Simpson, J., Smyth, W.F.: How many runs can a string contain? Theoretical Computer Science 401(1–3), 165–171 (2008) 5. Crochemore, M., Ilie, L.: Maximal repetitions in strings. J. Comput. Syst. Sci. 74, 796–807 (2008) 6. Baturo, P., Piatkowski, M., Rytter, W.: The number of runs in Sturmian words. In: Ibarra, O., Ravikumar, B. (eds.) CIAA 2008. LNCS, vol. 5148, pp. 252–261. Springer, Heidelberg (2008) 7. Giraud, M.: Not so many runs in strings. In: Mart´ın-Vide, C., Otto, F., Fernau, H. (eds.) LATA 2008. LNCS, vol. 5196, pp. 245–252. Springer, Heidelberg (2008) 8. Crochemore, M., Ilie, L., Tinta, L.: Towards a solution to the “Runs” conjecture. In: Ferragina, P., Landau, G.M. (eds.) CPM 2008. LNCS, vol. 5029, pp. 290–302. Springer, Heidelberg (2008) 9. Franˇek, F., Yang, Q.: An asymptotic lower bound for the maximal-number-of-runs function. In: Proc. Prague Stringology Conference (PSC 2006), pp. 3–8 (2006) 10. Franˇek, F., Simpson, R., Smyth, W.: The maximum number of runs in a string. In: Proc. 14th Australasian Workshop on Combinatorial Algorithms (AWOCA 2003), pp. 26–35 (2003) 11. Matsubara, W., Kusano, K., Ishino, A., Bannai, H., Shinohara, A.: New lower bounds for the maximum number of runs in a string. In: Proc. The Prague Stringology Conference 2008, pp. 140–145 (2008) 12. Crochemore, M., Ilie, L., Smyth, W.F.: A simple algorithm for computing the lempel ziv factorization. In: Proc. DCC 2008, pp. 482–488 (2008) 13. Graham, R., Knuth, D., Patashnik, O.: Concrete mathematics, 2nd edn. AddisonWesley, Reading (1995)

On Accepting Networks of Evolutionary Processors with at Most Two Types of Nodes Victor Mitrana1, and Bianca Truthe2 1

Faculty of Mathematics, University of Bucharest Str. Academiei 14, 70109 Bucharest, Romania and Department of Information Systems and Computation Technical University of Valencia, Camino de Vera s/n. 46022 Valencia, Spain [email protected] 2 Faculty of Computer Science, University of Magdeburg P.O.Box 4120, 39016 Magdeburg, Germany [email protected]

Abstract. In this paper we investigate the computational power of accepting networks of evolutionary processors (ANEP for short) with filters defined in two ways: by regular sets and random contexts conditions, respectively. We consider ANEPs with all the nodes specialized in only one evolutionary operation (substitution, insertion and deletion) or in two operations out of these three.

1

Introduction

Motivated by some models of massively parallel computer architectures (see [1], [2]), networks of language processors have been introduced in [3]. Such a network can be considered as a graph where the nodes are sets of productions and at any moment of time a language generated by these productions is associated with every node. Inspired by biological processes, a different variant of network of language processors which is called network with evolutionary processors has been introduced in [4]. The productions of the nodes in a network with evolutionary processors might be viewed as formal specifications of the point mutations known from biology. Each node is associated with a set of rules and all rules of a node are of the same type, namely either substitutions of one letter by another letter or insertions of letters or deletions of letters; each node is then called substitution node or insertion node or deletion node, respectively. The action of each node on the data it contains is precisely defined. An implicit assumption is that arbitrarily many copies of every word are available such that when a production can be applied at two or more sites in a word the production is applied at each site in different copies of the word. 

Work supported by the Alexander von Humboldt Foundation.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 588–600, 2009. c Springer-Verlag Berlin Heidelberg 2009 

On ANEPs with at Most Two Types of Nodes

589

In [5], a characterization of the complexity class NP based on accepting networks of evolutionary processors was presented. In [6], it was shown that every recursively enumerable language can be accepted by an accepting network of evolutionary processors with 24 nodes and random context filters. Such a network contains all types of nodes. Accepting networks of evolutionary processors with regular filters were first investigated in [7], where only networks without insertion nodes were considered. In [8], the generative capacity of networks with regular filters and only two types of nodes was studied. In the present paper, we try to complete the picture of computational power of ANEPs with at most two types of nodes.

2

Some Notations and Definitions

Throughout the paper we assume that the reader is familiar with the basic notions of the theory of formal languages. We here only recall some notation and notions as they are used in the paper. An alphabet is a finite and nonempty set of symbols. The cardinality of a finite set A is written card(A). Any sequence of symbols from an alphabet V is called word over V . The set of all words over V is denoted by V ∗ and the empty word is denoted by ε. A language over V is a subset of V ∗ . The length of a word x is denoted by |x| while alph(x) denotes the (with respect to inclusion) minimal alphabet W such that x ∈ W ∗ . We say that a rule a → b, with a, b ∈ V ∪ {ε} is a substitution rule if both a and b are not ε; it is a deletion rule if a = ε and b = ε; it is an insertion rule if a = ε and b = ε. The set of all substitution, deletion, and insertion rules over an alphabet V are denoted by SubV , DelV , and InsV , respectively. Given a rule σ as above and a word w ∈ V ∗ , we define the following actions of σ on w:  {ubv | ∃u, v ∈ V ∗ (w = uav)}, • If σ ≡ a → b ∈ SubV , then σ ∗ (w) = {w}, otherwise  {uv | ∃u, v ∈ V ∗ (w = uav)}, ∗ • If σ ≡ a → ε ∈ DelV , then σ (w) = {w}, otherwise   {u | w = ua}, {v | w = av}, σ l (w) = σ r (w) = {w}, otherwise {w}, otherwise • If σ ≡ ε → a ∈ InsV , then σ ∗ (w) = {uav | ∃u, v ∈ V ∗ (w = uv)}, σ r (w) = {wa}, σ l (w) = {aw}. The action α ∈ {∗, l, r} expresses the way of applying a substitution, a deletion or an insertion rule to a word, namely at any position (α = ∗), in the left (α = l), or in the right (α = r) end of the word, respectively. For every rule σ, any actionα ∈ {∗, l, r}, and any L ⊆ V ∗ , we define the α-action of σ on L by σ α (w). Given a finite set of rules M , we define the α-action of M σ α (L) = w∈L

on the word w and the language L by:

590

V. Mitrana and B. Truthe

M α (w) =

 σ∈M

σ α (w) and M α (L) =



M α (w),

w∈L

respectively. In what follows, we shall refer to the rewriting operations defined above as evolutionary operations since they may be viewed as linguistic formulations of local DNA mutations. If θ : V ∗ −→ {0, 1} is a predicate and L ⊆ V ∗ , we write θ(L) = L ∩ θ−1 (1). We are interested in some special predicates. For two disjoint subsets P and F of an alphabet V , a regular set R over V , and a word x over V , we define the predicates θs,P,F (x) = 1 if and only if P ⊆ alph(x) and F ∩ alph(x) = ∅, θw,P,F (x) = 1 if and only if alph(x) ∩ P = ∅ and F ∩ alph(x) = ∅, θR (x) = 1 if and only if x ∈ R. The conditions of the first two predicates is based on random context conditions defined by the two sets P (permitting contexts/symbols) and F (forbidding contexts/symbols). Informally, the first condition requires (s stands for strong) that all permitting symbols are and no forbidding symbol is present in x, while the second (w stands for weak) is a weaker variant such that at least one permitting symbol appears in x but still no forbidding symbol is present in x. We call these two predicates random context predicates. The third predicate asks for membership in a regular set, and is called a regular predicate. An evolutionary processor over V is a tuple (M, ϕ, ψ), where: – M is either a set of substitution, deletion, or insertion rules over the alphabet V ; formally, M ⊆ SubV or M ⊆ DelV or M ⊆ InsV . The set M represents the set of evolutionary rules of the processor. As one can see, a processor is “specialized” in one evolutionary operation, only, – ϕ is the input predicate, while ψ is the output predicate of the processor. Informally, these two predicates work as filters. A word w can enter or leave the processor, if it satisfies the predicate ϕ(w) or ψ(w), respectively. An evolutionary processor (M, ϕ, ψ) is non-inserting, if M is either a set of substitution or deletion rules, it is non-deleting, if M is either a set of substitution or insertion rules, it is non-substituting, if M is either a set of insertion or deletion rules. Further, a node is an insertion, a deletion, or a substitution node, if M ⊆ InsV , or M ⊆ DelV , or M ⊆ SubV , respectively. The set of all evolutionary processors is denoted by EPV . The set of all non-inserting, non-deleting, nonsubstituting, insertion, deletion, and substitution processors over V is denoted by NIEPV , NDEPV , NSEPV , IEPV , DEPV , or SEPV , respectively. We are interested in two types of filters: filters defined by random context conditions and filters defined by regular set conditions. An evolutionary processor X ∈ {NIEPV , NDEPV , NSEPV , IEPV , DEPV , SEPV } is called a random context X processor, denoted by rcX, if its both predicates are of the form θs,P,F or of the form θw,P,F for certain disjoint subsets P and F of V . Such a processor is called regular processor, denoted by regX if its both predicates are of the form θR for some regular set R ⊆ V ∗ .

On ANEPs with at Most Two Types of Nodes

591

An accepting network of evolutionary processors (ANEP for short) is a 7-tuple Γ = (V, U, G, N, α, xIn , Out), where: – V and U are the input and network alphabet, respectively, satisfying V ⊆ U . – G = (XG , EG ) is an undirected graph without loops with the set of vertices XG and the set of edges EG . G is called the underlying graph of the network. – N : XG −→ EPV is a mapping which associates with each node x ∈ XG the evolutionary processor N (x) = (Mx , ϕx , ψx ). – α : XG −→ {∗, l, r} is a mapping which associates with each node a type of action; α(x) gives the action mode of the rules of node x on the words existing in that node. – xIn ∈ XG is the input node of Γ . – Out ⊂ XG is the set of output nodes of Γ . In a similar way one can define the accepting networks of non-inserting, non-deleting, non-substituting, insertion, deletion, and substitution processors denoted by ANNIEP, ANNDEP, ANNSEP, ANIEP, ANDEP, and ANSEP, respectively. An accepting network as above is a random context or regular network if all its processors are random context or regular, respectively. We say that card(XG ) is the size of Γ . A configuration of an ANEP Γ as ∗ above is a mapping C : XG −→ 2Vf which associates a finite set of words with every node of the graph. A configuration may be understood as the sets of words which are present in any node (or in the associated processor) at a given moment. Given a word z ∈ V ∗ , the initial configuration of Γ on z is defined by (z) (z) C0 (xIn ) = {z} and C0 (x) = ∅ for all x ∈ XG \ {xIn }. A configuration can change either by an evolutionary step or by a communication step. When changing by an evolutionary step, each component C(x) of the configuration C is changed in accordance with the set of evolutionary rules Mx associated with the node x and the way of applying these rules α(x). Formally, we say that the configuration C  is obtained in one evolutionary step from the configuration C, written as C =⇒ C  , if and only if C  (x) = Mxα(x) (C(x)) for all x ∈ XG . When changing by a communication step, each node processor x ∈ XG sends one copy of each word it has, which is able to pass the output filter of x, to all the node processors connected to x and receives all the words sent by any node processor connected with x provided that they can pass its input filter. Formally, we say that the configuration C  is obtained in one communication step from configuration C, written as C  C  , if and only if  C  (x) = (C(x) − ψx (C(x))) ∪ (ψy (C(y)) ∩ ϕx (C(y))) for all x ∈ XG . {x,y}∈EG

Note that words that cannot pass the output filter of a node remain in that node and can be further modified in the subsequent evolutionary steps, while

592

V. Mitrana and B. Truthe

words that can pass the output filter of a node but cannot pass the input filter of any node are lost. Let Γ be an ANEP, the computation of Γ on the input word z ∈ V ∗ is a (z) (z) (z) (z) sequence of configurations C0 , C1 , C2 , . . . , where C0 is the initial configu(z) (z) (z) (z) ration of Γ on z, C2i =⇒ C2i+1 and C2i+1  C2i+2 , for all i ≥ 0. Note that the configurations are changed by alternative steps. By the previous definitions, each (z) (z) configuration Ci is uniquely determined by the configuration Ci−1 . A computation halts (and it is said to be weak (strong) halting) if one of the following two conditions holds: (i) There exists a configuration in which the set of words existing in at least one output node (all output nodes) is non-empty. In this case, the computation is said to be a weak (strong) accepting computation. (ii) There exist two identical configurations obtained either in consecutive evolutionary steps or in consecutive communication steps. The languages weakly or strongly accepted by Γ are defined as Lwa (Γ ) = {z ∈ V ∗ | the computation of Γ on z is a weak accepting} and Lsa (Γ ) = {z ∈ V ∗ | the computation of Γ on z is strong accepting}. In the theory of networks, some types of underlying graphs are common like rings, stars, grids, etc. Networks of evolutionary words processors, seen as language generating or accepting devices, with underlying graphs having these special forms have been considered in several papers, see, e. g., [9] for an early survey. We focus here on complete networks i. e., networks having a complete underlying graph. Therefore, in what follows we replace the graph G in the definition of an accepting network by the set of its nodes usually denoted by χ. Moreover, we present an evolutionary network by its nodes x and the parameters corresponding to x, where instead of ϕβ,P Ix ,F Ix and ψ β,P Ox ,F Ox , in case of  random context processors, and instead of ϕRx and ϕRx for regular processors, we only mention P Ix , F Ix , P Ox , F Ox , β and Rx , Rx , respectively. For an accepting mode x ∈ {wa, sa}, a type y ∈ {rc, reg} of filters, and Z ∈ {ANNIEP, ANNDEP, ANNSEP, ANIEP, ANDEP, ANSEP}, by Lx (yZ) we denote the set of all languages which can be weakly/strongly accepted by networks of type Z with filters of type y. Note that we ignore the empty word when we define a language and the empty set when we define a class of languages.

3 3.1

Computational Power of Random Context Networks Networks with Substitution Nodes

We start this section by establishing a relationship between the two classes Lwa (ANSEP) and Lsa (ANSEP). As it was expected, we have Theorem 1. Lwa (rcANSEP) ⊆ Lsa (rcANSEP).

On ANEPs with at Most Two Types of Nodes

593

Proof. Actually, we prove a bit more general result, namely that for every ANSEP Γ there exists an ANSEP Γ  with one output node only and Lwa (Γ ) = Lwa (Γ  ) = Lsa (Γ  ). Without loss of generality, we assume that the set of rules in every output node of Γ is empty and that all its filter types are strong. Indeed, if the filter type of one node is a weak one with P its input set of permitting symbols and F its input set of forbidding symbols, then this node can be replaced by 2card(P ) − 1 output nodes, each of them having a strong filter type where the input set of permitting symbols is a nonempty subset of P and the input set of forbidding symbols is F , respectively. Further on, the output set of permitting and forbidding symbols of every such node is {Z} and the empty set, respectively, where Z is a new symbol. Now, in order to get Γ  , we add one more node to Γ , which is the unique output node of Γ  . This node can receive only those words containing the new symbol Z. We now associate with each output node of Γ a set of substitution rules formed by one substitution only, namely X → Z, where X is an arbitrary symbol from the input set of permitting symbols of that node applied in the ∗ mode (if the input set of permitting symbols is empty, we take all substitution rules X → Z with X from the network alphabet).   The class of languages computed by rcANSEPs is rather strange because it contains all regular languages over the unary alphabet, non-context-free languages but there are even singleton languages that fail to be accepted in any way by rcANSEPs. The last assertion is immediate as any rcANSEP accepting a word of the form axb, where a and b are not necessarily equal, but x is a word of length at least two containing two distinct symbols, accepts also all words ayb with y being an arbitrary permutation of x. Theorem 2. The class Lwa (rcANSEP) is closed under union. Proof. According to [7], the class Lwa (rcANNIEP) is closed under union. There, for two networks Γ1 and Γ2 , a network Γ is constructed using the networks Γ1 , Γ2 and three additional substitution nodes such that Γ weakly accepts the language Lwa (Γ1 ) ∪ Lwa (Γ2 ). If both networks Γ1 and Γ2 have only substitution nodes, then also Γ has only substitution nodes.   Theorem 3. Every language R that is commutative and semi-linear can be weakly accepted by an rcANSEP. Proof. For every commutative, semi-linear language R ⊆ {a1 , a2 , . . . , ad }∗ , there exist natural numbers n ≥ 1, ri ≥ 0 for 1 ≤ i ≤ n and d-dimensional vectors pi and qi,j for 1 ≤ i ≤ n, 1 ≤ j ≤ ri such that R = ψ −1 (

n 

i=1

{pi +

ri  j=1

αi,j qi,j | αi,j ∈ N for 1 ≤ j ≤ ri })

594

V. Mitrana and B. Truthe

where ψ is the Parikh mapping. For 1 ≤ i ≤ n, let p

p

p

α

Hi = {a1i 1 a2i 2 . . . adi d a1 i,1

qi,1 1 αi,1 qi,1 2 a2

α

. . . ad i,1

qi,1 d αi,ri qi,ri 1 a1

αi,ri qi,ri d

. . . ad

| αi,j ∈ N, 1 ≤ j ≤ ri }. Then, R =

n 

COMM (Hi ) where COMM (Hi ) is the commutative closure of

i=1

Hi . An rcANSEP accepting Hi , for some 1 ≤ i ≤ n, can be constructed that contains ri + 1 subnetworks. A subnetwork substitutes pi 1 occurrences of a1 in the input word by the symbols (a1 , pi 1 , 1), (a1 , pi 1 , 2), . . . , (a1 , pi 1 , pi 1 ), then pi 2 occurrences of a2 by the symbols (a2 , pi 2 , 1), (a2 , pi 2 , 2), . . . , (a2 , pi 2 , pi 2 ) and so on. The derivation is not successful if the ak s are consumed before (ak , pi k , pi k ) is written (1 ≤ k ≤ d). Then the subnetwork for a number j, 1 ≤ j ≤ ri is choosen. This subnetwork receives words containing the symbols (a1 , pi 1 , 1), . . . , (ad , pi d , pi d ) and possibly a ¯. It substitutes qi,j k occurrences of ak by the symbols (ak , qi,j k , 1),  (ak , qi,j k , 2), . . . , (ak , qi,j k , qi,j k ) for k = 1, . . . , d as shown before. As soon as a word contains the symbols (ak , qi,j k , qi,j k ) for 1 ≤ k ≤ d, it enters a designated node where all these symbols are replaced by a ¯. The obtained word is now again an “input” for some subnetwork for a number j  until no occurrence of ak , 1 ≤ k ≤ d is observed in the current word. The output node of the network can receive only those words without any occurrence of a1 , . . . , ad but containing a symbol (ad , qi,j d , qi,j d ) for some number j ∈ {1, 2, . . . , ri }. The network informally described here weakly accepts Hi . By Theorem 2 (closure under union), there is also an rcANSEP that accepts the language R.   Corollary 1. Every regular language R over a unary alphabet can be weakly accepted by an rcANSEP. Proposition 1. The class Lwa (rcANSEP) contains non-context-free languages. Proof. We consider the language L = {w ∈ {a, b, c}+ | |w|a = |w|b = |w|c } which is not context-free. We explain how this language can be weakly accepted by an rcANSEP. Exactly one occurrence of a, b, and c, in this order, is replaced by a , b , c , respectively. Words containing c enter a node where the all the primed symbols are substituted by barred copies. Now the process resumes. When a word contains only barred symbols, it can enter the output node.   3.2

Networks with Deletion Nodes

The results on the computational power of rcANDEPs we present in this section are rather similar to those presented in the previous section. Namely, we show that non-context-free languages can be weakly and strongly accepted by

On ANEPs with at Most Two Types of Nodes

595

rcANDEPs but there are singleton languages that cannot be accepted in any mode by any rcANDEP. Proposition 2. The classes Lwa (rcANDEP) and Lsa (rcANDEP) contain noncontext-free languages. Proof. Let Γ be the following rcANDEP over the input alphabet {a, b, c, d, #} with one output node only: ⎧ ⎧ M = {a → ε}, M = {b → ε}, ⎪ ⎪ ⎪ ⎪ ⎨ ⎨ PI = {a, b, c, d, #}, FI = ∅, PI = {b, c, d, #}, FI = ∅, xIn : x1 : PO = ∅, FO = ∅, ⎪ PO = ∅, FO = ∅, ⎪ ⎪ ⎪ ⎩ ⎩ α = ∗, β = s, α = ∗, β = s, ⎧ ⎧ M = {c → ε}, M = {d → ε}, ⎪ ⎪ ⎪ ⎪ ⎨ ⎨ PI = {c, d, #}, FI = {a, b}, PI = {d, #}, FI = {a, b}, x2 : x3 : PO = ∅, FO = ∅, PO = ∅, FO = ∅, ⎪ ⎪ ⎪ ⎪ ⎩ ⎩ α = ∗, β = s, α = ∗, β = s, ⎧ M = ∅, ⎪ ⎪ ⎨ PI = {#}, FI = {a, b, c, d}, xOut : PO = ∅, FO = ∅, ⎪ ⎪ ⎩ α = ∗, β = s. Let x be an input for this network. We assume that x contains all the letters of the alphabet {a, b, c, d, #}. In the input node xIn , an arbitrary occurrence of a is deleted from x. All words obtained in this way are then received by x1 , where an arbitrary occurrence of b is deleted. All these words move to xIn again if a and b still occur. This “ping-pong” process continues until no occurrence of a and b is observed in the current word. If |x|a = |x|b , then the process of removing all occurrences of a and b is successful, while this process will eventually get stuck provided that |x|a = |x|b . Now all the words obtained from x by a successful process as above collapsed into only one word, say y, which contains occurrences of c, d and # only. This word enters simultaneously x2 and x3 , where an occurrence of c and d is deleted, respectively. Again a “ping-pong” game between the nodes x2 and x3 similar to that presented above takes place. All occurrences of c and d of y can be successfully deleted if and only if either |x|c = |x|d or |x|d = |x|c + 1. After they were successfully removed, the resulting word enters xOut and the computation ends by accepting the input word x. It follows Lwa (Γ )∩a+ c+ b+ #d+ = {an cm bn #dp | n, m ≥ 1, (p = m)∨(p = m+1)}, which implies that Lwa (Γ ) is not context-free. Moreover, Lwa (Γ ) = Lsa (Γ ) holds, which completes the proof.   We finish this section with the following result. Theorem 4. A language over the unary alphabet is weakly/strongly accepted by an rcANDEP if and only if it is one of these languages: {a}, {aa}, {a}{a}∗, or {aa}{a}∗.

596

V. Mitrana and B. Truthe

Proof. The reader can easily find rcANDEPs that weakly/strongly accept each of the languages mentioned in the statement. Conversely, one can easily prove that an rcANDEP having exactly one deletion node (except the output ones) can accept {a}, {a}{a}∗, or {aa}{a}∗. Further on, every rcANDEP with at least two deletion nodes (except the output ones) can accept one of the languages {a}, {aa}, {a}{a}∗, or {aa}{a}∗.   Corollary 2. Neither the class Lwa (rcANDEP) nor Lsa (rcANDEP) is closed under union. 3.3

Networks with Insertion Nodes

This case is pretty simple and can be solved completely. As far as the computational power of rcANIEPs is concerned, we can characterize precisely the class of languages computed by these networks. Theorem 5. A language L over the alphabet V is weakly/strongly accepted by an rcANIEP if and only if there are the subsets V1 , V2 , . . . , Vn of V , for some n ≥ 1, not necessarily pairwise disjoint, such that n  L= {x ∈ Vi+ | |x|a ≥ 1, for all a ∈ Vi }. i=1

Proof. It is plain that the language

n 

{x ∈ Vi+ | |x|a ≥ 1, for all a ∈ Vi } can be

i=1

weakly accepted by an rcANIEP for any subsets V1 , V2 , . . . , Vn of an alphabet V . The converse statement follows immediately as soon as we note that if a word z is weakly/strongly accepted by an rcANIEP Γ , then all words of the language   {x ∈ alph(z)+ | |x|a ≥ 1, for all a ∈ alph(z)} are also accepted by Γ . From Theorem 5, we obtain the following results. Corollary 3. Lwa (rcANIEP) = Lsa (rcANIEP). Corollary 4. Both classes Lwa (rcANIEP) and Lsa (rcANIEP) are closed under union. 3.4

Networks with Non-insertion Nodes

Networks with substitution and deletion nodes only have been studied by J. Dassow and V. Mitrana in [7]. Here, we recall only two results. Theorem 6. ([7]) 1. Lwa (rcANNIEP) ⊆ Lsa (rcANNIEP) ⊆ L(CS ). 2. The class Lwa (rcANNIEP) contains all linear context-free languages and nonsemi-linear languages.

On ANEPs with at Most Two Types of Nodes

3.5

597

Networks with Non-substitution Nodes

Similar to Theorem 1 we can prove that Lwa (rcANNSEP) ⊆ Lsa (rcANNSEP) (instead of substitution rules, we use insertion rules in the output nodes). The addition of insertion nodes brings more computational power to rcANDEPs as well as the addition of deletion nodes brings more computational power to rcANIEPs. The proofs of the next two results are skipped by limited space reason. Proposition 3. For every k ≥ 1, the language Lk = {an | 1 ≤ n ≤ k} belongs to Lwa (rcANNSEP). Two networks Γ1 , Γ2 can be combined with additional nodes to a network Γ such that a word is accepted by Γ if and only if it is accepted by Γ1 or Γ2 . Theorem 7. The class Lwa (rcANNSEP) is closed under union. 3.6

Networks with Non-deletion Nodes

We can show the following result by the same proof as for Theorem 1 since the constructed network differs from the original one only in substitution nodes. Theorem 8. Lwa (rcANNDEP) ⊆ Lsa (rcANNDEP). Analogously to Theorem 2, we can show Theorem 9. The class Lwa (rcANNDEP) is closed under union. Let A = {a} be a unary input alphabet. Let I, D, S, N I, N D, and N S be the set of all languages weakly accepted by an insertion network over the alphabet A, by a deletion network, by a substitution network, by a non-inserting network, by a non-deleting network, and by a non-substituting network, respectively. By the Theorems 5 and 4, Corollary 1, Proposition 3, we obtain the inclusions shown in Figure 1. A (solid) arrow stands for (proper) inclusion. The sets N I and N S are not necessarily uncomparable.

4 4.1

8 N Dd S = NI fM

MMM MM

DO

:N S vv v v v

I Fig. 1. Hierarchy

Computational Power of Regular Networks Networks with Non-insertion Nodes

In [7], it was shown that regular networks with only substitution and deletion nodes always accept context-sensitive languages and that every context-sensitive language can be accepted by such a network where the number of nodes depends linearly in the number of rules necessary for generating the language. Here, we show that one substitution node alone is sufficient.

598

V. Mitrana and B. Truthe

Theorem 10. For any context-sensitive language L, there is an accepting regular network Γ with exactly one substitution node and one output node without rules that weakly and strongly accepts the language L. Proof. Let L be a context-sensitive language and G = (N, T, P, S) be a grammar in Kuroda normal form with L(G) = L. Let R1 , R2 , . . . , R8 be the following sets (A, B, C, D denote non-terminal symbols): R1 R2 R3 R4 R5 R6 R7 R8

= { x → xp,0 , xp,0 → A | A → x ∈ P, A ∈ N, x ∈ N ∪ T } , = { C → Cp,1 | p = A → CD ∈ P or p = AB → CD ∈ P } , = { D → Dp,2 | p = A → CD ∈ P or p = AB → CD ∈ P } , = { Cp,1 → Cp,3 | p = A → CD ∈ P or p = AB → CD ∈ P } , = { Dp,2 → Dp,4 | p = A → CD ∈ P or p = AB → CD ∈ P } , = { Cp,3 → A | p = A → CD ∈ P or p = AB → CD ∈ P } , = { Dp,4 → B | p = AB → CD ∈ P } , = { Dp,4 → | p = A → CD ∈ P } .

We construct a network Γ of with the input alphabet T , the network alphabet   { xp,0 } ∪ { Cp,1 , Dp,2 , Cp,3 , Dp,4 } V =N ∪T ∪{ } p=A→x

p=A→CD p=AB→CD

and two nodes. The input node is (M1 , ∅, O1 ) with M1 = R1 ∪ R2 ∪ R3 ∪ R4 ∪ R5 ∪ R6 ∪ R7 ∪ R8 , and O1 = { }∗ {S}{ }∗ ∪ {ε} ∪ V ∗ \ ((N ∪ T ∪ { })∗ O(N ∪ T ∪ { })∗ ), where O = { ε } ∪ { xp,0 | p = A → x ∈ P, A ∈ N, x ∈ N ∪ T } ∪ { Cp,1 | p = A → CD ∈ P or p = AB → CD ∈ P } ∪ { Cp,1 ωDp,2 | p = A → CD ∈ P or p = AB → CD ∈ P, ω ∈ { }∗ } ∪ { Cp,3 ωDp,2 | p = A → CD ∈ P or p = AB → CD ∈ P, ω ∈ { }∗ } ∪ { Cp,3 ωDp,4 | p = A → CD ∈ P or p = AB → CD ∈ P, ω ∈ { }∗ } ∪ { AωDp,4 | p = A → CD ∈ P or p = AB → CD ∈ P, ω ∈ { }∗ } .

{ }∗ {S}{ }∗ ∪ {ε} if ε ∈ L, The output node is (∅, I2 , ∅) with I2 = { }∗ {S}{ }∗ otherwise. The network Γ has only one output node. Therefore, there is no difference between weak and strong acceptance. By a case distinction on the rules of G, one can prove that any derivation w =⇒∗ v with v = ε of the grammar G can be simulated by the network Γ in reverse direction (by a reduction v =⇒∗ w) and, on the other hand, a word v ∈ N ∪ T can only be transformed into a word w ∈ N ∪ T if the derivation w =⇒∗ v exists in G. Since a substitution node cannot delete letters, we replace letters by the symbol instead. When simulating a derivation w =⇒ v in G, we have to take into account that the corresponding word in the substitution node   may contain gaps in form of several occurrences of the special symbol .

On ANEPs with at Most Two Types of Nodes

4.2

599

Networks of Non-deleting Nodes

The main difference between context-sensitive and non-context-sensitive grammars is that, in arbitrary phrase structure grammars, erasing rules are allowed. In order to simulate an erasing rule in reverse direction, we introduce an insertion node. Theorem 11. For any recursively enumerable language L, there is an accepting network of evolutionary processors with exactly one substitution node, one insertion node and one output node without rules that weakly and strongly accepts the language L. Proof. The idea of the proof is to extend the network Γ constructed in the proof of Theorem 10 by an inserting processor who is responsible for the reverse simulation of erasing rules. Between two simulation phases, the substitution node can mark a symbol such that the word can leave the node and enter the insertion node. This processor inserts a non-terminal that belongs to an erasing rule and returns the word to the substitution node. This processor then has to unmark the primed symbol. If marking or unmarking is not performed in the correct moment, the word will be lost.   4.3

Networks without Substitution Processors

In [8], we have shown that every recursively enumerable language can be generated by a network of one inserting processor and one deleting processor. Similar to the proof of that statement, we can prove the following result. Theorem 12. For any recursively enumerable language L, there is an accepting network of evolutionary processors with exactly one deletion node, one insertion node and one output node without rules that weakly and strongly accepts the language L. Acknowledgements. We thank J¨ urgen Dassow for stimulating discussions and ideas on this topic.

References 1. Hillis, W.: The Connection Machine. MIT Press, Cambridge (1985) 2. Fahlman, S., Hinton, G., Seijnowski, T.: Massively parallel architectures for AI: NETL, THISTLE and Boltzmann Machines. In: Proc. AAAI National Conf. on AI, pp. 109–113. Morgan Kaufmann, Los Altos (1983) 3. Csuhaj-Varj´ u, E., Salomaa, A.: Networks of parallel language processors. In: P˘ aun, G., Salomaa, A. (eds.) New Trends in Formal Languages. LNCS, vol. 1218, pp. 299–318. Springer, Heidelberg (1997) 4. Castellanos, J., Mart´ın-Vide, C., Mitrana, M., Sempere, J.: Solving NP-complete problems with networks of evolutionary processors. In: Mira, J., Prieto, A.G. (eds.) IWANN 2001. LNCS, vol. 2084, pp. 621–628. Springer, Heidelberg (2001)

600

V. Mitrana and B. Truthe

5. Margenstern, M., Mitrana, V., Perez-Jimenez, M.: Accepting hybrid networks of evolutionary processors. In: Ferretti, C., Mauri, G., Zandron, C. (eds.) DNA 2004. LNCS, vol. 3384, pp. 235–246. Springer, Heidelberg (2005) 6. Manea, F., Mitrana, V.: All NP-problems can be solved in polynomial time by accepting hybrid networks of evolutionary processors of constant size. Information Processing Letters, 112–118 (2007) 7. Dassow, J., Mitrana, V.: Accepting networks of non-inserting evolutionary processors. In: Petre, I., Rozenberg, G. (eds.) Proceedings of NCGT 2008 – Workshop on Natural Computing and Graph Transformations, Leicester, United Kingdom, September 8, 2008, pp. 29–41. University of Leicester (2008) 8. Alhazov, A., Dassow, J., Mart´ın-Vide, C., Rogozhin, Y., Truthe, B.: On networks of evolutionary processors with nodes of two types. Fundamenta Informaticae (in press, 2009) 9. Mart´ın-Vide, C., Mitrana, V.: Networks of evolutionary processors: results and perspectives. In: Molecular Computational Models: Unconventional Approaches, pp. 78–114. Idea Group Publishing, Hershey (2005)

The Halting Problem and Undecidability of Document Generation under Access Control for Tree Updates Neil Moore University of Kentucky, Department of Computer Science Lexington, Kentucky 40506-0046 [email protected]

Abstract. We show by reduction from the halting problem for Turing machines that typical rule-based models of fine-grained access control of trees make impossible certain forms of analysis, limiting the ability to audit existing policies and evaluate new ones. Fine-grained access control is the problem of specifying the set of operations that may be performed on a complex structure. For tree-structured databases and documents, particularly XML, a rule-based approach is most common. In this model, access control policies consist of rules that select the allowed or disallowed targets of queries based on their hierarchical relationships to other nodes. We consider the problem of determining whether a given document (that is, a rooted vertex-labelled tree) could have been produced in accordance with a particular access control policy for updates. We show that, for rule-based policies based on a simple fragment of XPath, this problem is undecidable. This result shows that rule-based access control policies based on XPath languages are, in some sense, too powerful, demonstrating the need for a model of access control of tree updates that bridges the gap between expressive and analyzable policies.

1

Motivation and Related Work

In the past few years the topic of fine-grained access control (FGAC) for hierarchical structures has been heavily studied, particularly in the context of Extensible Markup Language (XML) [1] documents. The problem is to specify and enforce an access control policy that determines which portions of a document or collection of documents may be queried or modified by particular users. A rule-based approach is prevalent in the literature [2,3,4]: in this model, an access control policy comprises a collection of rules. Each rule permits or denies a user, group, or role (the subject) to use a particular kind of operation on certain parts of the document (the object). Objects are typically nodes or subtrees of the document, specified with a language of path expressions, usually XPath [5] or some fragment thereof [6,7]. While most of the early research on FGAC for XML focused on query operations [2,3,8], there has more recently been work in applying FGAC to update operations [9,10,11,12]. Two problems have been particularly well-studied: A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 601–613, 2009. c Springer-Verlag Berlin Heidelberg 2009 

602

N. Moore

specifying and formalizing the semantics of FGAC policies [4,12,13,14], and safely and efficiently enforcing these policies [2,11]. We consider another problem, related to the analysis of policies: to determine a posteriori whether a document could have been constructed under a given access control policy. This problem, which we call PolicyGenerates, is motivated by a number of database administration and collaborative editing scenarios. For example, an administrator might wish to audit a document by verifying that it was (or at least could have been) created under the existing policy; this is particularly important when logs of previous operations are missing or unavailable. Another application is to evaluate a proposed policy change, by verifying that existing documents could be reconstructed under the policy. Finally, an algorithm for PolicyGenerates would allow administrators to verify that particular undesirable document states are disallowed: that is, that the policy does not generate particular trees. We will show in Section 3 that this problem is undecidable.

2

Definitions

We begin with a collection of definitions. We use the term “tree” to refer to a rooted unordered tree, with nodes bearing a labels from some given set L. Definition 1. An operation on a tree T is a tuple having the form (insert, μ, ), (rename, ν, ), or (delete, ν), where ν is a node of T , μ is either ε or a node of T , and  is a label. The second member of an operation (μ or ν) is called its target. Definition 2. The result O(T ) of an operation O on tree T is: – If O = (insert, ν, ), the tree obtained from T by adding a single additional node labelled  as a child of ν. – If O = (insert, ε, ) and T is empty, the tree with a single node labelled . – If O = (insert, ε, ) and T is not empty, T . – If O = (rename, ν, ), the tree obtained from T by giving node ν the label . – If O = (delete, ν), the tree obtained by removing the subtree rooted at ν. The result of a sequence of operations o1 , . . . , on  on a tree T is the tree on (on−1 (· · · o1 (T ) · · · )). Remark 1. Our operations are loosely based on those of XUpdate [15]. The rename and delete operations are unchanged from their counterparts in XUpdate. Insert serves as an order-insensitive version of the XUpdate operations InsertBefore, InsertAfter, and Append. Furthermore, unlike in XUpdate, insert adds only a single node at a time; more complicated insertions can be accomplished by a sequence of operations We do not include an replace operation, as its effects can be duplicated by a sequence of insert and delete operations. Rules in FGAC policies identify potential targets of operations by means of path expressions. Typically, path expressions are expressed in XPath [5] or

The Halting Problem and Undecidability of Document Generation

603

some XPath fragment such as Core XPath or XPattern [16]. Our rules will use the XP{[],∗,//} fragment of XPath, containing predicates, path expressions, and the child and descendant axes. This fragment of XPath has been particularly well studied [6,7]. Briefly, a path expression consists of a sequence of location steps that select nodes along the path from the root to the target according to their labels. If a location step is preceded by /, it selects (appropriately-labelled) children of the preceding node; if preceded by //, it selects descendants of that node. A location step may be followed by a number of predicates, each a path expression surrounded by square brackets []; the location step selects a node only if each predicate selects some descendant of that node. Some examples: – – – –

/∗ selects the root node, regardless of its name. //m selects every node labelled m. /w/x//y selects every y descendant of an x child of the root w node. //x[∗/q]/z selects every z node that is the child of some x node that has a grandchild q.

Definition 3. An access control rule is a tuple with the form (s, insert, P, L), (s, delete, P ), or (s, rename, P, L), where: s is either + (positive) or − (negative); P is a path expression (possibly the empty path expression ε); and L is either a label or the symbol ∗, matching all labels. Definition 4. A rule R matches the operation O on tree T , written R ∼T O, if and only if one of the following holds: – R = (s, insert, ε, L), O = (insert, ε, ), T is empty, and either L =  or L = ∗; – R = (s, insert, P, L), O = (insert, ν, ), P selects ν in T , and L is  or ∗; – R = (s, rename, P, L), O = (rename, ν, ), P selects ν in T , and L is  or ∗; or – R = (s, delete, P ), O = (delete, ν), and P selects ν in T . Definition 5. A positive rule R with path expression P is active on tree T if it matches some possible operation on T : that is, if P (T ) is not the empty set; or if T is the empty tree, P = ε, and R is an insert rule. Definition 6. An access control policy is a finite set of access control rules. The policy P permits the operation O on tree T , written P T O, if there exists some positive rule R ∈ P such that R ∼T O and there does not exist a negative rule R− ∈ P such that R− ∼T O. If S = o1 , . . . , on  is a finite sequence of operations, we say that P permits S on tree T (P T S) if P Ti−1 oi for each 1 ≤ i ≤ n, where T0 = T and Ti = oi (Ti−1 ). Remark 2. Our model uses “deny overwrites” and “default deny” conflict resolution [4,14]: if an operation is matched by both positive and negative rules, or is matched by no rule, it is not permitted.

604

N. Moore

Remark 3. In order to facilitate analysis of FGAC rules and policies, we have made some simplifying assumptions. First, we disregard subjects in our model of policies. Even when multiple users are present, many important questions can be expressed in terms of subject-less policies, either by considering only rules governing a particular subject, or by considering all rules regardless of subject. Secondly, we treat documents and databases as unordered trees. Our results may be easily extended to policies containing multiple subjects, and to ordered trees. With these preliminary definitions out of the way, we may now formally define the problem PolicyGenerates. Definition 7. A policy P generates the tree T if there exists some finite sequence of operations S such that P T0 S and S(T0 ) = T , where T0 is the empty tree. The problem PolicyGenerates is the set of pairs (P, T ) such that P generates T .

3

Undecidability of PolicyGenerates

We will prove that, in our model of FGAC policies for tree updates, PolicyGenerates is undecidable. Our proof proceeds by reduction from the halting problem for Turing machines. We will show how to encode a Turing machine M and initial tape S as an access control policy PM,S such that PM,S generates a particular tree Thalt if and only if M halts on input S. We represent a Turing machine as a 7-tuple of a set of states, an initial state, a set of final (accepting) states, a tape alphabet, an input alphabet, a blank symbol, and a transition function. M = (Q, q0 ∈ Q, QF ⊆ Q, Γ, Σ ⊂ Γ, b ∈ Γ \ Σ, δ) We consider deterministic Turing machines with left and right moves only, where no transitions are permitted from final states: that is, the transition function δ maps from (Q \ QF ) × Γ to Q × Γ × {L, R}. Furthermore, we assume the tape is bounded on the left. A configuration is a tuple (q, t, p) of a state q ∈ Q, a tape t ∈ Γ ∗ , and a tape position 1 ≤ p ≤ |t|. We write C0M,S for the initial configuration of Turing machine M on input S, namely (q0 , S, 1). We write Δ for the function taking a configuration to the succeeding configuration. 3.1

Modelling Turing Configurations as Trees

A tree generated by PM,S will represent a configuration of M , as well as additional bookkeeping information necessary to the simulation. Definition 8. Let C = (q, t, p) be a configuration of the Turing machine M = (Q, q0 , QF , Γ, b, Σ, δ). The configuration tree of C, conftree(C), is the tree described in Figure 1.

The Halting Problem and Undecidability of Document Generation – – – – – –

3.2

605

a root node labelled tm; tm three children, labelled ph, state, and tape; state phase tape one child of the ph node, labelled run; one child of the state node, labelled q; qi run cell one child C1 of the tape node, labelled cell; each cell node Ci (1 ≤ i ≤ |t|) having: sym curr cell • one child labelled sym, itself having a child laγ1 sym belled with the tape symbol t[i]; γ2 • if i < |t|, one child Ci+1 labelled cell; • if i = p, one child labelled curr. Fig. 1. A configuration tree

The Policy PM,S

Let M = (Q, q0 , QF , Γ, Σ, b, δ) be a Turing machine, and S = S1 S2 . . . Sn ∈ Σ ∗ an initial tape for M . The policy PM,S will simulate the action of M on input S. It consists of the following rules and (finite) rule schemata. (−, insert, /tm[ph], ph)

(1)

(+, insert, /tm, ph)

(12)

(−, insert, /tm[state], state)

(2)

(13)

(−, insert, /tm[tape], tape)

(+, insert, /tm/ph, build)

(3)

(+, insert, /tm[ph/build], state)

(14)

(−, insert, /tm/ph[∗], ∗)

(4)

(15)

(−, insert, /tm/state[∗], ∗)

(+, insert, /tm[ph/build], tape)

(5)

(+, insert, /tm[ph/build]/state, q0 )

(16)

(−, insert, //∗[cell], cell)

(6)

(17)

(−, insert, //cell[curr], curr)

(+, insert, /tm[ph/build]/tape, cell)

(7)

(−, insert, //cell[new], new)

(+, insert, /tm[ph/build]/tape/cell, curr) (18)

(8)

(−, insert, //cell[sym], sym)

(+, insert, /tm[ph/build]/tape//cell, sym)

(9)

(19)

(−, insert, //sym[∗], ∗)

(10)

(+, insert, ε, tm)

(11)

(+, insert, /tm[ph/build]/tape/cell/sym, S1 ) (20)

For each i, 1 < i ≤ |S|, let “· · · ” stand for i−1 repetitions of the path fragment “/cell”: (+, insert, /tm[ph/build]/tape · · ·, cell)

(21)

(+, insert, /tm[ph/build]/tape · · · [sym/∗]/cell/sym, Si )

(22)

And a single rule where “· · · ” represents |S| − 1 repetitions of the path fragment /cell:   (23) +, rename, /tm[state/q0 ][tape/cell[curr] · · · /sym/S|S| ]/ph/build, run For each final state qf ∈ QF : (+, insert, /tm[ph/run][state/qf ], finished) 

(24) 

For (q, γ) ∈ (Q \ QF ) × Γ , where δ(q, γ) = (q , γ , D): (+,  +,  +,  +,

rename, /tm[state/q][tape//cell[curr][sym/γ]]/ph/run, write-q-γ)  rename, /tm[ph/write-q-γ]/tape//cell[curr]/sym/γ, γ   rename, /tm[ph/write-q-γ]/state/q, q  rename, /tm[state/q  ][tape//cell[curr]/sym/γ  ]ph/write-q-γ, move-q-γ

(+, delete, /tm[ph/move-q-γ][tape//new]/tape//curr)

(25) (26) 

(27) (28) (29)

(+, rename, /tm[tape//cell/new]/ph/move-q-γ, cleanup)

(30)

(−, rename, /tm[tape//cell/curr]/ph/move-q-γ, ∗)

(31)

606

N. Moore

If D = L: (+, insert, /tm[ph/move-q-γ]/tape//cell[cell/curr], new)

(32)

Otherwise, D = R: (+, insert, /tm[ph/move-q-γ]/tape//cell[curr], cell)

(33)

(+, insert, /tm[ph/move-q-γ]/tape//cell, sym)

(34)

(+, insert, /tm[ph/move-q-γ]/tape//cell[curr]/cell/sym, b)

(35)

(+, insert, /tm[ph/move-q-γ]/tape//cell[curr]/cell[sym/∗], new)

(36)

Finally:

3.3

(+, rename, /tm[ph/cleanup]//new, curr)

(37)

(+, rename, /tm[tape//curr]/ph/cleanup, run)

(38)

(+, delete, /tm[finished]//∗)

(39)

Simulation Phases

Our Turing machine simulation proceeds from one configuration tree to the next by proceeding through a number of phases. The tree’s current phase is indicated by the label of the child of the ph node. In each phase, a particular sequence of operations is permitted, ending with a transition into the successor phase. There are three independent phases build, run, and cleanup; and 2|Q \ QF | · |Γ | phases that depend on the simulated machine’s state q and the contents γ of its current tape cell; these phases are labelled write-q-γ and move-q-γ. We begin by noting that the negative Rules 1–10 enforce certain constraints on the tree. These structural rules ensure that there is only one copy of each top-level node (ph, state, and tape); that the state and ph nodes have only a single child each; that no tape cell contains two symbols or two successor tape cells; and that no cell is marked as “current” or “new” twice. At the beginning of our simulation, the tree is empty, and hence does not have a phase. In this stage, we construct enough of the tree to enter the build phase. Because every other positive rule in PM,S requires the existence of a child of the /tm/ph node, only Rules 11–13 are active at this point. We therefore have the following: Lemma 1. Any sufficiently long sequence of operations that is permitted on the null tree must pass through an intermediate tree containing exactly: a tm root, one ph child of the root, and one build child of that node. Remark 4. Because an operation that would insert a root node is not permitted on a non-empty tree, Rule 11 can be used only once. Likewise, structural Rules 1 and 4 prevent Rules 12 and 13 from being activated again as long as the tree contains a ph node. Hence we shall disregard Rules 11–13 in the following lemmas. Build Phase. In the build phase, we complete the initial configuration tree, including the state and tape nodes and their descendants. At the end of this phase, once the entire initial configuration tree is constructed, we permit transitioning to the run phase.

The Halting Problem and Undecidability of Document Generation

607

Lemma 2. Any sufficiently long sequence of operations permitted on the null tree must produce the tree conftree(C0M,S ) as an intermediate step. Proof. Lemma 1 established that such a sequence of operations must produce as an intermediate step a tree with a /tm/ph/build node, ph and tm ancestors, and no other nodes. On such a tree, only Rules 14 and 15 permit further operations. Once a state node has been inserted by Rule 14, Rule 16 permits inserting a q0 child; Rules 2 and 5 ensure that at most one state node and one child of that node are inserted. After applying Rule 15 to insert a tape node, Rules 17–20 allow inserting a cell child; curr and sym grandchildren; and a S1 child of the sym node. Once the cell node has been inserted, the instances of Rule 21 allow inserting i − 1 cell descendants, each a child of the previous node. Rule 6 ensures that neither the tape node nor the cell nodes may contain multiple cell children; and Rule 7 prevents applying Rule 18 again. For each of the cell nodes, Rules 19 and 22 allow inserting sym children, and grandchildren labelled with the appropriate symbol. Furthermore, the [sym/∗] predicate in the latter rule ensures that no symbol is inserted until the previous symbol (and hence all preceding symbols) are inserted. Finally, Rule 23 allows renaming the build node to run, but only after the q0 node and last cell’s symbol (and hence all |S| symbols) have been inserted. Since all other positive rules contain predicates which require that the ph node contain some child other than build, these are the only rules that permit operations before Rule 23 is applied. Along with the structural rules, this ensures that any sequence of 3 + 2 + 1 + 4 + 3|S − 1| = 3|S| + 7 operations must result in a tree where Rule 23 is the only applicable positive rule that is not blocked by negative rules. Applying this rule results in precisely the tree conftree(C0M,S ). Hence any permitted sequence of length 3|S| + 8 must yield this tree, and any longer permitted sequence will produce this tree as an intermediate result.  Run Phase. The run phase represents a Turing machine configuration. This phase can be entered from the build phase (Rule 23), or from the cleanup phase (Rule 38). The only operations permitted in this phase are to rename the run node to the next phase, one of the write phases; to insert a finished node if the configuration is a final one; and to delete most of the tree when the finished node is present. Lemma 3. If C is not a final configuration (that is, its state is not a member of QF ), then exactly one operation is permitted on conftree(C), resulting in a tree Tw , otherwise identical to conftree(C), but with a write-q-γ node replacing the run node, where q is the state of C and γ is the symbol in the current tape cell of C. Proof. Other than Rules 11–13, which are blocked by structural rules, the only positive rules whose predicates are satisfied by a tree in the run phase without a

608

N. Moore

finished node are instances of Rule schemata 25 and 24; only the former is active for a non-final configuration. This rule transforms the tree into precisely Tw .  Write Phases. For each transition, that is to say each pair (q, γ) ∈ (Q\QF )×Γ , the phase write-q-γ allows changing the configuration tree’s state and current tape symbol. It is followed by the move-q-γ and cleanup phases, where the position of the tape head is adjusted. Lemma 4. Let C be a Turing machine configuration with state q and current symbol γ; let Tw be the tree resulting from Lemma 3; and let (q  , γ  , D) = δ(q, γ). Any permitted sequence of operations on Tw that results in a tree without a write-q-γ node must as an intermediate step pass through a tree Tm that differs from Tw in that: the child of the ph node is labelled move-q-γ; the child of the state node is labelled q  ; and the child node of the sym sibling of the curr node is labelled γ  . Proof. In this phase, only Rules 26–28 are active. Only the last of these rules permits renaming the write-q-γ node. This rule’s predicates allow it to be used only if the state node has a child labelled q  and the current tape cell node ζ has a grandchild labelled γ  . These are precisely the state and tape value specified by δ(q, γ). Rule 27 permits renaming the state node q to q  ; and Rule 26 permits renaming the γ grandchild of ζ to γ  ; since these are the only three active rules, no other operations are permitted in this phase. Hence, immediately after applying Rule  28, the tree is precisely the described Tm . Remark 5. Unlike in the other phases, it is not the case that any sufficiently long sequence of operations leads to the next phase. If a cell is being re-written with the same symbol, or the transition does not change the Turing machine state, is possible to apply Rule 26 or 27 an arbitrary number of times. However, since in this case the rule in question does not alter the tree, the result does not differ from applying the rule only once. Move Phases. When the move-q-γ phase is entered, the tree’s state and current tape symbol have been updated. It remains to move the tape head, adding a new cell if necessary. This is accomplished in two phases: in the move phase, we mark the updated tape head position as “new” and remove the “current” mark. Then, in the cleanup phase, we change the “new” mark to “current”. Lemma 5. Let C = (q, t, p) be a Turing machine configuration; let Tm be the tree resulting from Lemma 4; and let D be the directional component of δ(q, γ). If the p = 1 and D = L (a hanging configuration), no operations are permitted on Tm . Otherwise, let ζ be the cell node of Tm containing a curr child. Any sufficiently long sequence of permitted operations of Tm must as an intermediate step pass through the tree Tc that is otherwise identical to Tm , but without a curr node, with the move-q-γ node replaced with cleanup node, and with changes depending on D and p:

The Halting Problem and Undecidability of Document Generation

609

– If D = L and p > 1, then the parent of ζ in Tc contains a child labelled new. – If D = R and p = |t|, then ζ in Tc contains a new cell child, containing two children labelled new and sym, with the latter having a child node with the blank cell label b. – Otherwise, D = R and p < |t|; then the cell child of ζ in Tc contains a child labelled new. Proof. The positive rules active in this phase are instances of Rules 29 and 30; if D = L, Rule 32; and if D = R, Rules 33–36. Furthermore, the negative Rules 6, 8, 9, 10, and 31 are relevant to the operation of this phase. Rules 29 and 30 are not active on Tm , because the tree contains no new node. We consider separately the two directions in which the tape head may move. If D = L, only Rule 32 is active on Tm . This rule permits inserting a new node as a child of the parent cell node of ζ. If p = 1, the parent of ζ is the tape node; hence no operations are permitted. Otherwise, after inserting the new node, Rule 8 prohibits inserting another such node; and Rule 29 becomes active. Once this rule is used to delete the curr node, Rule 31 is no longer active, leaving Rule 30 as the only active rule; applying this rule renames the move-q-γ node to cleanup, yielding Tc . Hence, any permitted sequence of three operations must yield Tc . If D = R, there are two cases to consider. If p < |t|, only Rules 33 and Rule 36 are active; and because ζ has a cell child, Rule 6 prohibits inserting a node with the former rule. Hence the only permitted operation is to insert a new child of the cell child of ζ. After this, the argument from the D = L case applies: the next operation must be to delete the curr node, then to rename the move-q-γ node. Hence any permitted sequence of three operations must yield Tc . If p = |t|, Rule 36 is not active, because ζ has no cell children. Thus the only permitted operation is to insert a new cell child of ζ by Rule 33; Rule 6 prohibits inserting more than one such node. After this node has been inserted, Rule 34 permits inserting a sym node (but only once because of Rule 9). Then Rule 35 allows inserting a blank symbol node b as a child of this node, but only once because of Rule 10. Once these three operations have been performed, Rule 36 is active and the other rules inactive; then we may proceed as in the p < |t| case.  Hence any permitted sequence of six operations must yield Tc . Cleanup Phase. After the write and move phases, the tree has almost completely been updated to reflect the new Turing machine configuration. The only remaining steps are to replace the new marker node with a curr node, and to enter the run phase again, yielding the tree for the successor configuration. Lemma 6. Let C be a Turing machine configuration and let Tc be the tree resulting from applying Lemmas 3, 4, and 5 to conftree(C). Any sufficiently long sequence of operations permitted on Tc must produce as an intermediate result the tree T  , otherwise the same as Tc , but with a curr node in place of the new node, and a run node in place of the cleanup node. Proof. In the cleanup phase, positive Rules 37 and 38 are active; the latter is not active on Tc because it contains no curr node. Hence the only permitted

610

N. Moore

operation is to rename the new node to curr by the former rule. Performing this operation deactivates Rule 37, because there is no longer a new node. Hence the second operation must be to rename the cleanup node to run by Rule 38, resulting in the desired tree T  . Thus any permitted sequence of two operations on Tc yields T  .  Halting. Finally, if the simulation reaches a final configuration, a finished node is inserted, and the tree is pared down to just the tm and finished nodes. Lemma 7. If C = (qf , t, p) is a final configuration (that is, qf ∈ QF ), there is a sequence of operations permitted on T = conftree(C) that yields the tree Thalt containing a root node labelled tm, a child node labelled finished, and no other nodes. Proof. The tree T contains nodes with paths /tm/ph/run and /tm/state/qf ; hence Rule 24 is active and it is permitted to insert a finished node. Once this node has been added, Rule 39 becomes active, allowing any non-root node in the tree to be deleted. In particular, it is permitted to delete the ph, state, and  tape nodes, leaving precisely Thalt . 3.4

Correctness of Simulation

Lemma 8. Let C be a non-final Turing machine configuration, and let Q be any non-empty sequence of operations permitted on T = conftree(C) such that Q(conftree(C)) contains a node labelled /tm/ph/run. Then Q produces conftree(Δ(C)) as an intermediate result, representing the successor configuration Δ(C). Furthermore, if C is not a hanging configuration, such a sequence Q exists. Proof. After applying Lemmas 3 through 6 to the tree T = conftree(C), we have a tree T  that is otherwise identical to T , except that: its state is q  ; the symbol of the previous tape cell ζ (the cell that was current in conftree(C)) is γ  ; the parent (if D = L) or child (if D = R) cell of ζ is marked as current; and if ζ had no cell children and D = R, a new child cell with symbol b has been inserted. These are precisely the changes necessary to transform conftree(C) into conftree(Δ(C)). If any of these changes had not been performed, the resulting tree could not have a /tm/ph/run node.  Figure 2 demonstrates the sequence of phases for a typical transition involving a rightwards move. Theorem 1. Let M be a Turing machine and S ∈ Σ ∗ an initial tape of M ; and let Thalt be the tree containing only a tm root and a finished child. Then PM,S generates Thalt if and only if M halts on input S. Proof. By Lemmas 1 and 2, PM,S generates the tree T1 = conftree(C0M,S ), and any sufficiently long permitted sequence of operations must produce this tree as an intermediate step. If M halts on input S after k steps, then k applications

The Halting Problem and Undecidability of Document Generation

tm

phase

tape

state

phase

qi

run

cell

qk

q i γ1

sym

tm

tm

state

curr

write sym

cell

γ1

611

tape

state

cell

qk

curr

phase move q i γ1

sym

cell

tape

cell curr

cell

γ’

γ’

sym

sym

sym

γ2

γ2

γ2

tm

new

tm

state

phase

tape

state

phase

tape

qk

cleanup

cell

qk

run

cell

sym

cell

γ’

sym

cell

γ’

sym

curr

γ2

sym

curr

γ2

Fig. 2. Simulating the Turing machine transition δ(qi , γ1 ) = (qk , γ  , R). First row: a configuration tree in phase run, and the tree at the end of phases write, move. Second row: the tree at the end of phase cleanup, and the successor configuration tree.

of Lemma 8 produces a configuration tree for a final configuration. From such a tree, by Lemma 7 there is a permitted sequence of operations that yields Thalt . Now suppose M does not halt on input S. Then there is an infinite sequence of configurations C0 , C1 , . . . such that each Ci+1 = Δ(Ci ). Suppose S is a permitted sequence of operations resulting in Thalt . Then, as argued above, S must as an intermediate step produce a tree containing a run node and a qf ∈ QF node. By Lemma 8, this sequence must produce as an intermediate result the tree conftree(C1 ). Repeated applications of Lemma 8 demonstrates that the sequence must subsequently produce intermediate results conftree(C2 ), conftree(C3 ), and in general conftree(Ci ) for each i ∈ N. However, this means that S is an infinite sequence, contradicting the assumption that it is a permitted sequence. Hence  no such sequence exists, so PM,S does not generate Thalt . Corollary 1. PolicyGenerates is undecidable. Proof. Given a Turing machine M and input tape S, it is possible to construct the policy PM,S algorithmically (in fact, in polynomial time). Combined with Theorem 1, this establishes a many-to-one reduction from the halting problem to PolicyGenerates. Since the halting problem is undecidable, so too is PolicyGenerates. 

4

Conclusions and Future Work

We have shown that, unfortunately, the most common forms of XML access control policies preclude certain kinds of analysis, because their expressiveness

612

N. Moore

makes PolicyGenerates undecidable. This points to the need for less expressive, but still practical and flexible, models of and languages for fine-grained access control of tree updates. Restricting updates to only insert makes the problem decidable: each operation inserts a single node, so for a tree with n nodes we need check only sequences of operations of length n. However, access control policies that do not allow updates to existing data are useless for many practical purposes. Another change, restricting policies to only positive rules, might make PolicyGenerates decidable; this is a topic for future research. However, the promise of this approach is limited, as it may be shown by reduction from the true quantified boolean formula problem that this simplified subproblem is still PSpace-hard. If we eliminate predicates in our path expressions, we have the fragment XP{∗,//} of XPath [6]. This is a much simpler language, because nodes are selected based entirely on their sequence of ancestors. However, this path expression language is incapable of expressing important constraints such as uniqueness of a node or uniqueness of a node’s children. When the mechanical analysis and verifiability of policies is important, a different approach to fine-grained access control of tree updates may be necessary. Proposed models that warrant further investigation include multi-level security of trees [8] and schema-based access control [17]. Acknowledgments. I would like to thank my research advisor Dr. Jerzy W. Jaromczyk for very helpful advice, discussions, and support, without which this paper would not have been possible. I would also like to thank the reviewers, whose helpful comments led to numerous improvements in the final version of this paper.

References 1. Bray, T., Paoli, J., Sperberg-McQueen, C.M., Maler, E., Yergeau, F., Cowan, J.: Extensible markup language (XML) 1.1. World Wide Web Consortium Recommendation (2004), http://www.w3.org/TR/2004/REC-xml11-20040204/ 2. Bertino, E., Braun, M., Castano, S., Ferrari, E., Mesiti, M.: Author-X: A Javabased system for XML data protection. In: Proceedings IFIP TC11/WG11.3 Fourteenth Annual Working Conference on Database Security: Data and Application Security, Development and Directions, pp. 15–26 (2000) 3. Damiani, E., De Capitani di Vimercati, S., Paraboschi, S., Samarati, P.: Securing XML documents. In: Zaniolo, C., Grust, T., Scholl, M.H., Lockemann, P.C. (eds.) EDBT 2000. LNCS, vol. 1777, p. 121. Springer, Heidelberg (2000) 4. Hada, S., Kudo, M.: XML Access Control Language: Provisional authorization for XML documents. Technical Report, Tokyo Research Laboratory, IBM Research (2000), http://www.trl.ibm.com/projects/xml/xacl/xacl-spec.html 5. Clark, J., DeRose, S.: XML path language (XPath), version 1.0. World Wide Web Consortium Recommendation (1999), http://www.w3.org/TR/1999/REC-xpath-19991116 6. Deutsch, A., Tannen, V.: Containment of regular path expressions under integrity constraints. In: Knowledge Representation Meets Databases (2001)

The Halting Problem and Undecidability of Document Generation

613

7. Miklau, G., Suciu, D.: Containment and equivalence for a fragment of XPath. J. ACM 51(1), 2–45 (2004) 8. Cho, S., Amer-Yahia, S., Lakshmanan, L.V., Srivastava, D.: Optimizing the secure evaluation of twig queries. In: Proceedings 28th VLDB Conference (2002) 9. Lim, C.H., Park, S., Son, S.H.: Access control of XML documents considering update operations. In: Proceedings 2003 ACM Workshop on XML Security (2003) 10. Cautis, B., Abiteboul, S., Milo, T.: Reasoning about XML update constraints. In: PODS 2007: Proceedings of the twenty-sixth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pp. 195–204. ACM, New York (2007) 11. Damiani, E., Fansi, M., Gabillon, A., Marrara, S.: Securely updating XML. In: Apolloni, B., Howlett, R.J., Jain, L. (eds.) KES 2007, Part III. LNCS, vol. 4694, pp. 1098–1106. Springer, Heidelberg (2007) 12. Fundulaki, I., Maneth, S.: Formalizing XML access control for update operations. In: Lotz, V., Thuraisingham, B.M. (eds.) SACMAT, pp. 169–174. ACM, New York (2007) 13. Bertino, E., Catania, B., Ferrari, E., Perlasca, P.: A logical framework for reasoning about access control models. ACM Trans. Inf. Syst. Secur. 6(1), 71–127 (2003) 14. Fundulaki, I., Marx, M.: Specifying access control policies for XML documents with XPath. In: Proceedings 9th ACM Symposium on Access Control Models and Technologies, pp. 61–69 (2004) 15. Laux, A., Martin, L.: XUpdate—XML update language. Working Draft (2000), http://xmldb-org.sourceforge.net/xupdate/xupdate-wd.html 16. Gottlob, G., Koch, C., Pichler, R.: Efficient algorithms for processing XPath queries. In: Proc. of the 28th International Conference on Very Large Data Bases (VLDB 2002) (2002) 17. Bravo, L., Cheney, J., Fundulaki, I.: ACCOn: checking consistency of XML writeaccess control policies. In: Kemper, A., Valduriez, P., Mouaddib, N., Teubner, J., Bouzeghoub, M., Markl, V., Amsaleg, L., Manolescu, I. (eds.) EDBT. ACM International Conference Proceeding Series, vol. 261, pp. 715–719. ACM, New York (2008)

Prediction of Creole Emergence in Spatial Language Dynamics Makoto Nakamura1, Takashi Hashimoto2 , and Satoshi Tojo1 1

School of Information Science, Japan Advanced Institute of Science and Technology 1-1, Asahidai, Nomi, Ishikawa, 923-1292, Japan 2 School of Knowledge Science, Japan Advanced Institute of Science and Technology 1-1, Asahidai, Nomi, Ishikawa, 923-1292, Japan {mnakamur,hash,tojo}@jaist.ac.jp Abstract. Creole is a new born language emerging in most cases where language contact takes place. Simulating behaviors that creole communities are formed in some environments, we could contribute to actual proof of some linguistic theories concerning language acquisition. Thus far, a simulation study of the emergence of creoles has been reported in the mathematical framework. In this paper we introduce a spatial structure to the framework. We show that local creole communities are organized, and creolization may occur when language learners learn often from non-parental language speakers, in contrast to the non-spatial model. The quantitative analysis of the result tells us that emergence of local colonies at the early stage tends to induce the full creolization.

1

Introduction

Computer simulation of diachronic change in human languages has widely been reported in the study of language evolution [1,2], where interactions among individuals affect language spoken throughout the community, dependent upon the abilities of individuals or the learning environment. Among those simulations, the emergence of pidgins and creoles is one of the most interesting phenomena in language change [3,4,5]. Pidgins are simplified tentative languages spoken in multilingual communities, which come into being where people need to communicate but do not have a language in common. On the other hand, creoles are full-fledged new languages based on the pidgins in later generations. For example, Hawaiian Creole English emerged among plantation workers coming from Hawaii, China, the Philippines, Japan, Korea, Portugal, Puerto Rico and so on in the 19th century to the beginning of the 20th century. Since they needed to communicate with farm owners, they first formed Hawaiian pidgin based on English; later their offspring immersed with the pidgin had developed the language to one with its own grammatical structure. In general, grammar of a creole is different from any contact languages, although its vocabulary is often borrowed from them. Our goal in this paper is to discover specific conditions under which creoles emerge. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 614–625, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Prediction of Creole Emergence in Spatial Language Dynamics

615

Thus far, we proposed a mathematical framework for the emergence of creoles [6] based on the language dynamics equation by Nowak et al. [7], showing that creoles become dominant under specific conditions of similarity among languages and linguistic environment of language learners. Our purpose in the present study is to introduce a spatial structure to our model, in order to observe selforganization process of creole community. Especially, in this paper we compare behaviors of the two models. A related work for introducing a spatial structure into a mathematical model of language change has been done by Castell´ o et al. [8], who have analyzed a spatial version of a mathematical framework by Abrams et al. [9]. Different from Abrams-Strogatz’s model, our model [6] is well-defined in terms of learning algorithm and a learning environment. Introducing a spatial structure to a mathematical framework, we expect to observe a process of creolization and then to obtain more precise conditions from the model more similar to the environment where actual language phenomena took place. We recognize this study to fill the gap between the study of multiagent models and mathematical models. In Section 2, we describe the modified language dynamics model and a learning algorithm, and in Section 3 we define a creole in population dynamics. Section 4 reports our experiments, and we conclude in Section 5.

2

Population Dynamics for the Emergence of Creole

In this section, we briefly explain how to divert a mathematical model proposed by Nakamura et al. [6] to the one with a spatial structure. The most remarkable point in the model of Nakamura et al. [6] is to introduce an exposure ratio α, which determines how often language learners are exposed to a variety of language speakers other than their parents. They modified the learning algorithm of Nowak et al. [7], taking the exposure ratio into account to model the emergence of creole community. Nakamura et al. [6] have shown that a certain range of α is necessary for a creole to emerge. 2.1

Language Dynamics Equation for the Emergence of Creole

In response to the language dynamics equation by Nowak et al. [7], Nakamura et al. [10] assumed that any language could be classified into one of a certain number (n) of grammars. Thus, the population of language speakers is distributed to {G1 . . . Gn }. Let xi be the proportion of speakers of Gi within the total population. Then, the language dynamics is modeled by an equation governing the transition of language population. Because Nowak et al. [7] assumed that language speakers bore offspring in proportion to their successful communication, they embedded a fitness term in their model which determined the birth rate of each language group. The model for creolization has excluded the biological fitness, on the assumption that in the real world creoles did not emerge because creole speakers had more offspring than speakers of other pre-existing languages, that is:

616

M. Nakamura, T. Hashimoto, and S. Tojo n

dxj (t)  q ij (t)xi (t) − xj (t) . = dt i=1

(1)

In the language dynamics equations, the similarity matrix S and the transition matrix Q(t) play important roles: the similarity matrix S = {sij } is defined as a probability that a sentence of Gi is accepted also by Gj . Children learn a language in accordance with a learning algorithm, in which the accuracy varies depending on the similarity among languages. The transition matrix Q(t) = {qij (t)} is defined as a probability that a child of Gi speaker acquires Gj , and is calculated based on the learning algorithm. Being different from the definition by Nowak et al. [7], the definition of Q(t) depends on the generation parameter t, as well as the S matrix and a learning algorithm. 2.2

Introducing Spatial Structure

In the spatial model, we use the language distribution in neighbors surrounding each agent to calculate the local transition probability Q, by which each agent acquires a language, while a child is exposed to the whole population in a nonspatial model. (l) Hereafter, replacing xi for xi as a population rate of Gi speakers surrounding an agent at location l, equations are applicable to the spatial structure, too. We (l) calculate Q (t) for each agent every generation. 2.3

Learning Algorithm

In some communities, a child learns language not only from his/her parents but also from other adults, whose language may be different from the parental one. In such a situation, the child is assumed to be exposed to other languages, and thus may acquire the grammar most efficient in accepting multiple language input. In order to assess how often the child is exposed to other languages, we divide the language input into two categories: one is from his/her parents, and the other is from other language speakers. We name the ratio of the latter to the total amount of language input an exposure ratio α. This α is subdivided into smaller ratios corresponding to those other languages, where each ratio is in proportion to the population of the language speakers. An example distribution of languages is shown in Figure 1(a). Suppose a child has parents who speak Gp , s/he receives input sentences from Gp on the percentage of the shaded part, αxp +(1−α), and from non-parental languages Gi (i = p) on the percentage, αxi . We have adopted a batch learning algorithm, which resolves Niyogi [11]’s problem regarding an unrealistic Markov structure which implies that some children cannot learn certain kinds of language. From the viewpoint of universal grammar, that all conceivable grammars of human beings are restricted to a finite set [12], language learning is considered as a choice of a plausible grammar from them. The following algorithm realizes such learning as: 1) In a child’s memory, there is supposed to be a score table of grammars. 2) The child receives a sentence uttered by an adult. 3) The acceptability of the sentence is tested using

Prediction of Creole Emergence in Spatial Language Dynamics

617

Non-Spatial Model Population Rate:

x1

x2

x3

Spatial Model Parent: Neighbors:

α

1- α

G1 Gp Gn

Input Sentences:

α:

1

2

3

4

1−α:

7

8

9

10

G1

Gp

5 1

G3 (a) The exposure ratio α

42 6 3

8

9 10 7

G2

5

6 6 5 4 2 1

10 9 8 7 6 4 2

7 6 3 1

G1 G2 G3

(b) The learning algorithm

Fig. 1. The learning algorithm including the exposure ratio α

each grammar. The grammar which accepts the sentence scores one point. 4) Steps 2) and 3) are repeated until the child receives a fixed number (w) of sentences, which is regarded as sufficient for the decision of the grammar selection. 5) The child adopts the grammar with the highest score. The child is exposed to utterances of adult speakers of each language, the percentage of which is determined by the distribution of population and the exposure ratio α, while the S matrix determines the acceptability of a sentence. In Figure 1(b), we show an example where a child of G2 speaker obtains G2 after exposure to a variety of languages. The child receives sentences, which are boxes numbered from 1 to 10. The input sentences are divided into two sets according to the exposure ratio α. One of the sets consists of sentences of all grammars. The number of the sentences of each language is proportional to the population share of the language speakers. For example, the child hears sentences 1, 4 and 5 uttered by G1 speakers. The other consists of sentences of his/her parents. Therefore, these sentences are acceptable by a particular grammar. Because his/her parental grammar is G2 , for example, the sentences 7 to 10 are randomly chosen from the language of G2 . The child counts acceptable sentences for each grammar. The sentence 1 can be accepted by G3 as well as G1 , while it is uttered by a G1 speaker. The Venn diagram in Figure 1(b) represents that each language shares sentences with others. In this case, because the sentence 1 is acceptable both by G1 and by G3 , the child adds 1 to both of the counters in his/her mind. 2.4

Revised Transition Probability

Suppose that children hear sentences from adult speakers depending on the exposure ratio and on the distribution of population. A probability that a child whose parents speak Gi accepts a sentence by Gj is expressed by:

618

M. Nakamura, T. Hashimoto, and S. Tojo

Uij = α

n 

skj xk + (1 − α)sij .

(2)

k=1

After receiving a sufficient number of sentences for language acquisition, the child will adopt the most plausible grammar, as estimated by counting the number of sentences accepted by each grammar. This learning algorithm is simply represented in the following equation. Exposed to a variety of languages in proportion to the population share of adult speakers, children whose parents speak Gi will adopt Gj ∗ by: (3) j ∗ = argmax{Uij } . j

When the children hear w sentences, a probability that a child of Gi speaker accepts r sentences with Gj is given by a binomial distribution,   w (Uij )r (1 − Uij )w−r . (4) gij (r) = r On the other hand, a probability that the child accepts less than r sentences with Gj is r−1    w hij (r) = (5) (Uij )k (1 − Uij )w−k . k k=0

From these two probability distributions, the probability that a child of Gi speaker accepts k sentences with  Gj , while less than k − 1 sentences with the n other grammars, comes to gij (k) l=1,l=j hil (k). For a child of Gi speaker to acquire Gj after hearing w sentences, Gj must be the most efficient grammar among n grammars; viz., Gj must accept at least  w n  sentences. Thus, the probability q ij becomes the sum of the probabilities that Gj accepts w, w−1, · · · ,  w n sentences. Because each of the sentences is uttered by a speaker and is accepted by at least one grammar, there must be a grammar which accepts  w n  or more out of w sentences. Thus, if Gj accepts less than  w  sentences, the child does n not acquire Gj . Therefore, q ij becomes:  w  n   hil (k) + R(k, n) gij (k) k= w n

q ij (t) =

n 



l=1 l=j

 , w  n   hil (k) + R(k, n) gim (k)

m=1 k= w n

(6)

l=1 l=m

where R(k, n) is the sum total of the probabilities that the child would choose Gj when one or more other grammars accept the same number of sentences as Gj . When there are m candidate grammars including Gj , the probability becomes one divided by m. The following expression is an example when n = 3. Rij (k, 3) = 13 {gij (k)gij2 (k)gij3 (k)} + 12 {gij (k)gij2 (k)hij3 (k) + gij (k)hij2 (k)gij3 (k)} (j2 , j3 ∈ {1, 2, 3}, j = j2 , j3 , j2 = j3 )

(7)

Prediction of Creole Emergence in Spatial Language Dynamics

619

1

Population Share

0.8

x1 x2 x3

0.6 0.4 0.2 0 0

5

10

t

15

20

25

Fig. 2. Example of creolization ((a, b, c) = (0, 0.3, 0.4), w = 10, α = 0.7)

3

Creole in Population Dynamics

Creoles are considered as new languages. From the viewpoint of population dynamics, we define a creole as a transition of population of language speakers. A creole is a language which no one spoke in the initial state, but most people have come to speak at a stable generation. Therefore, creole is represented by Gc such that: xc (0) = 0, xc (t) > θc , where xc (t) denotes the population share of Gc at a convergent time t, and θc is a certain threshold to be regarded as a dominant language. We set θc = 0.9 through the experiments. For convenience, we have mainly observed the behavior of the model using three grammars. The similarity matrix can be expressed as a symmetric matrix such that: ⎛ ⎞ 1ab S = ⎝a 1 c⎠ . (8) bc1 Here, we regard G3 as a creole grammar, giving the initial condition as (x1 (0), x2 (0), x3 (0)) = (0.5, 0.5, 0). Therefore, the element a denotes the similarity between two pre-existing languages, and b and c are the similarities between G1 and the creole, and between G2 and the creole, respectively. We show an example of creolization in Figure 2. The parameters were set to (a, b, c) = (0, 0.3, 0.4), w = 10, and α = 0.7. Note that the conditions in the parameter space for dominant creoles are limited [13].

4

Experiments and Results

The spatial structure is a toroidal 50-by-50 square grid. Each agent has 8 neighbors. Each agent chooses one of three languages every generation, two of which, G1 and G2 , are pre-existing and randomly distributed with the same total number at the initial state. The remaining language, G3 , is a creole, having a certain similarity between two languages. The similarity means the probability that a sentence uttered by a Gi speaker is accepted by Gj . In this paper, We take the following values: (a, b, c) = (0, 0.3, 0.4), and w = 10 for the number of input sentences.

620

M. Nakamura, T. Hashimoto, and S. Tojo

(a) Generation 0

(b) Generation 10

(c) Generation 50

(d) Generation 100

(e) Generation 500

(f) Generation 1552

Fig. 3. Example of the spatial dynamics (white:G1 , black:G2 , gray:G3 ; α = 0.7)

4.1

Behaviors of Spatial Dynamics

We show an example of the spatial dynamics in Figure 3; (a) Only G1 and G2 are distributed at the initial stage. (b,c) Some local communities (hereafter colonies) of creole are organized at the early stage. (d,e) Both G1 , G2 and creole coexist at a quasi-stable stage. (f) In this trial, the creole eventually becomes dominant at Generation 1552. Agents surrounded by both G1 and G2 neighbors are likely to acquire the creole. In fact, creole speakers often appear on the border between communities. This is because the large value of α makes the agents to be exposed to both languages, and the creole is the most efficient for accepting input utterances from both languages. In general, learners tend to form a colony, regardless of the languages, affected from its neighbors during learning acquisition. However, the smaller the value of α, the slower the forming colonies. This is because the learners are hardly affected by neighbors, hearing their mother tongue from their parents. Note that even if α = 0, it is possible for a learner to acquire a language other than his/her mother tongue due to the similarity among languages. The number of input sentences is also relevant to forming a colony. Learners hearing a lot of language input become conservative in terms of changing his/her language. That is, once a small colony has been formed at a generation, inhabitants in the colony come to choose the same language as the previous generation. On the contrary, if learners choose a

Prediction of Creole Emergence in Spatial Language Dynamics

621

G1 G2 Creole

Probability of dominance

1

No dominant language

0.8

0.6

0.4

0.2

1.000

0.950

0.900

0.850

0.800

0.750

0.700

0.650

0.600

α

0.550

0.500

0.450

0.400

0.350

0.300

0.250

0.200

0.150

0.100

0.050

0.000

0

Fig. 4. Probability of dominant language in the spatial model

language with less language input, they tend to be undetermined in choosing a language. As a result, it is difficult to form a colony. 4.2

Comparing the Two Models with and without a Spatial Structure

We examine the probability of dominance for each language (Figure 4). Note that the spatial model is based on a stochastic dynamics. This graph is the result of 100 runs for 1,000,000 generations at each α value. The corresponding result in the non-spatial model is the population distribution at the stable generation, shown in Figure 51 , since the non-spatial model is based on the deterministic dynamics. This parameter set makes creole dominant at the range 0.1  α  0.8. In the spatial model, the probability that the creole is dominant gradually decreases from α > 0.3, and it becomes 0.3 around α > 0.8. In general, the larger the value of α, the more prominent the transition of population becomes, and in some cases, the transition leads to creolization. In Figure 5, however, the dominant language changes between the creole and G2 at α  0.8, and it is not always true that creoles are more likely to become dominant at the larger value of α (See [6]). Since children of a G1 speaker become more exposed to G2 in the larger value of α, it is possible for them to acquire G2 directly instead of the creole, and vice versa. Therefore, the population of the creole remains small and the children of creole speakers are likely to acquire G2 rather than G1 . Thus, the dominant language changes to G2 at α  0.82 . These differences between the results shown in Figure 4 and Figure 5 can be understood by considering local interaction and stochastic dynamics. The preexisting language may be able to form a colony due to stochasticity. Once a colony with certain size is formed, agents in the colony are surrounded by the 1 2

In other words, the result of the population distribution at the stable generation in Figure 2 is plotted at α = 0.7 in Figure 5. In the experiments, we have chosen this parameter set with which creoles tend to appear in the wide range of α.

M. Nakamura, T. Hashimoto, and S. Tojo

Population Distribution Ratio

622

x1 x2 x3

1

0.8 0.6 0.4 0.2 0 0

0.2

0.4

α

0.6

0.8

1

Fig. 5. Stable population distribution in the non-spatial model

same language and the exposure ratio effectively comes to α = 0. This situation is hard for the creole speakers to organize a colony. Thus, the probability to be dominant is restrained by the pre-existing language at the middle-high range of α. At the higher range of α, the creole can organize a colony at the early stage with certain ratio through random migration. The colony can grow to the whole space. 4.3

Quantitative Analysis in Forming Creole Communities

Observing behaviors of the spatial dynamics, we realized that forming creole colonies at early stages plays a key role for creolization. Large creole colonies are difficult to vanish and are able to encroach upon a territory of other languages. In other words, if creole speakers fail to form a certain size of colony before the quasi-stable stage, it is difficult for creole to become dominant. Therefore, in this section we try to predict whether creolization takes place or not at the early stage, observing creole colonies quantitatively. For a quantitative description of the emergence and dynamics of linguistic spatial domains we use the ensemble average interface density ρ as an order parameter, following a precedent work [8]. This is defined as the density of links joining nodes in the network which are in different states [14]. For associating with the population distribution, we use the inverse value as ρ = 1 − ρ. The ensemble average, indicated as ·, denotes average over realizations of the stochastic dynamics starting from different random distributions of initial conditions. As the time proceeds, the increase of ρ from its initial value describes the ordering dynamics, where linguistic spatial domains, in which agents are in the same state, grow in time. The maximum value ρ = 1 corresponds to a stationary configuration in which all the agents belong to the same linguistic community. In addition, we defined ρi as the density of Gi speakers’ neighbors which are in the same states. We analyzed difference of the behaviors at the early stage among 100 trials every α, shown in Figure 4, classifying the trials into three, each of which denotes the corresponding language eventually becomes dominant. We recognize an early

Prediction of Creole Emergence in Spatial Language Dynamics

1

(a)

G1 1

0.6 0.4 0.2 0.2

0.4

(c)

0.6 α G3

0.8

1

0.4

0.6

0.2

0.4

α

0.6

0.8

1

ρ ρ1 ρ2 ρ3

0.4 0.2 00

00

x1 x2 x3

0.8 x&ρ

0.6

0.2

00 1

G2

0.8 x&ρ

x&ρ

0.8

(b)

623

0.2

0.4

α

0.6

0.8

1

Fig. 6. Difference of xi and ρi  at the early stage (x3  0.2) between results in which G1 , G2 , and G3 eventually become dominant respectively

stage as the earliest generation at which x3 (t) exceeds 0.2 in each trial. Figure 6 shows the difference of the average ρ, ρi , and xi every α at the early stage between G1 , G2 and G3 becoming dominant at the stable generation. At some values of α in Figure 6(a) and (b), the values of x3 are partially plotted less than 0.2, because in some trials x3 never exceeded 0.2. In this case, we took the values at the stable generation for the average calculation. At some values of α where no data are plotted, there was no trial in which the corresponding language became dominant. Therefore, Figure 6 corresponds to the frequency distribution of dominance, shown in Figure 4. In Figure 6, we can see that ρ3  is lower than other densities at any value of α. Note that the average density of Gi denoted by ρi  is affected not only by a degree of forming colonies but also by its population3 . Therefore, it is natural that only 20 percent of the population obtains the density smaller than others. As was mentioned in Section 4.2, creolization takes place even at the large value of α (0.8  α), while G2 dominates the community in the non-spatial model (Figure 5). We can see that the values of ρ3  in Figure 6(c) are higher than that of (a) and (b). This tendency can be seen with other parameters of w 3

Suppose there is only a colony of Gi forming a square in the space. If the size of the colony is 5-by-5, ρi  = 0.72, while it is 0.855 for a 10-by-10 colony.

624

M. Nakamura, T. Hashimoto, and S. Tojo

and S. Therefore, we consider that forming creole colonies at the early stage is important for full creolization. On the contrary, at small values of α, the values of ρ3  are also small. Because the exposure ratio α determines a probability that a language learner communicates with its neighbors, forming a colony with neighbors is hardly effective in creolization at the small value of α. Rather, the creole becomes dominant due to an advantageous parameter set of w, S, and α. It is clear as evidenced by the result of the non-spatial model.

5

Conclusion

In this paper, we introduced a spatial structure to a mathematical framework of creolization. Observing this process, we discovered that forming colonies was an important factor. We showed that in the spatial language dynamics, creole could be dominant even in the high exposure ratio, different from the non-spatial model. The quantitative analysis implies that there is a condition of creolization in terms of a combination between the ensemble average density ρ3  and the exposure ration α. Through the experiments, we can conclude as follows: – Creole is easy to dominate the community in a parameter set where creolization takes place in the non-spatial model, regardless of the value of α. – The value of ρ3  is probably useful for the prediction of creolization at the early stage at the large values of α. We need to analyze the behavior through further experiments. Although we used a toroidal 50-by-50 square grid for a spatial structure, it can be expanded to more complicated social networks. There is yet room for improvement in some settings including the initial population distribution.

Acknowledgment This work was partly supported by Grant-in-Aid for Young Scientists (B) (KAKENHI) No.20700239 from MEXT Japan.

References 1. Cangelosi, A., Parisi, D. (eds.): Simulating the Evolution of Language. Springer, London (2002) 2. Briscoe, E.J. (ed.): Linguistic Evolution through Language Acquisition: Formal and Computational Models. Cambridge University Press, Cambridge (2002) 3. Arends, J., Muysken, P., Smith, N. (eds.): Pidgins and Creoles. John Benjamins Publishing Co., Amsterdam (1994) 4. Bickerton, D.: Language and Species. University of Chicago Press (1990) 5. DeGraff, M. (ed.): Language Creation and Language Change. MIT Press, Cambridge (1999)

Prediction of Creole Emergence in Spatial Language Dynamics

625

6. Nakamura, M., Hashimoto, T., Tojo, S.: Exposure dependent creolization in language dynamics equation. In: Sakurai, A., Hasida, K., Nitta, K. (eds.) JSAI 2003. LNCS (LNAI), vol. 3609, pp. 295–304. Springer, Heidelberg (2007) 7. Nowak, M.A., Komarova, N.L., Niyogi, P.: Evolution of universal grammar. Science 291, 114–118 (2001) 8. Castell´ o, X., Egu´ıluz, V.M., Miguel, M.S., Loureiro-Porto, L., Toivonen, R., Saram¨ aki, J., Kaski, K.: Modelling language competition: bilingualism and complex social networks. In: Smith, A., Smith, K., Cancho, R. (eds.) The Evolution of Language: Proceedings of the 7th International Conference (EVOLANG7), p. 85. World Scientific Pub. Co. Inc., Singapore (2008) 9. Abrams, D.M., Strogatz, S.H.: Modelling the dynamics of language death. Nature 424, 900 (2003) 10. Nakamura, M., Hashimoto, T., Tojo, S.: Creole viewed from population dynamics. In: Proc. of the Workshop on Language Evolution and Computation in ESSLLI, Vienna, pp. 95–104 (2003) 11. Niyogi, P.: The Informational Complexity of Learning. Kluwer, Boston (1998) 12. Chomsky, N.: Lectures on Government and Binding. Foris, Dordrecht (1981) 13. Nakamura, M., Hashimoto, T., Tojo, S.: Simulation of common language acquisition by evolutionary dynamics. In: Proc. of IJCAI 2007 Workshop on Evolutionary Models of Collaboration, Hyderabad, pp. 21–26 (2007) 14. Miguel, M.S., Eguiluz, V.M., Toral, R., Klemm, K.: Binary and multivariate stochastic models of consensus formation. Computing in Science and Engg. 7, 67–73 (2005)

On the Average Size of Glushkov’s Automata Cyril Nicaud LIGM, UMR CNRS 8049, Universit´e Paris Est, 77454 Marne-la-Vall´ee, France [email protected]

Abstract. Glushkov’s algorithm builds an ε-free nondeterministic automaton from a given regular expression. In the worst case, its number of states is linear and its number of transitions is quadratic in the size of the expression. We show in this paper that in average, the number of transitions is linear.

1

Introduction

Kleene’s Theorem states that regular expressions and automata describe the same objects, regular languages. They both are finite objects which encode infinite sets of words and they play a key role in formal language theory as well as in its many fields of application. One can often take advantage of having this two different representations, the algorithmic problems of transforming one representation into another are therefore fundamental. They have been widely studied and are still improved nowadays, as one can see in a recent survey by J. Sakarovitch [1]. In this paper we focus on one particular such transformation, Glushkov’s algorithm [2], an algorithm that builds an ε-free nondeterministic automaton from a given regular expression. Starting from a regular expression with n letters, it builds an automaton with n + 1 states and O(n2 ) transitions. In [3], J. Hromkovi˜c, S. Seibert and T. Wilke proposed a variation on this algorithm where the produced automaton has O(n log2 n) states. They also proved a lower bound of Ω(n log n) states for this general problem. Based on this work, C. Hagenah and A. Muscholl proposed in [4] an algorithm of time complexity O(n log2 n) to achieve the construction. See also [5,6] for some efficient related algorithms. Our contribution is to give an average case analysis of the size of Glushkov’s automata. Using the framework of analytic combinatorics, we prove that for the uniform distribution of regular expressions, the average number of transitions is linear. The use of generating functions and complex analysis have proved to be useful in average case analysis of algorithms [7]. The methodology we shall use here can be summarized as follows: 1. Find an unambiguous specification of the objects, which can be recursive. 2. Transform the specification into a functional equation for the associated generating function. 

The author is supported by the ANR (GAMMA - project BLAN07-2 195422).

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 626–637, 2009. c Springer-Verlag Berlin Heidelberg 2009 

On the Average Size of Glushkov’s Automata

627

3. Analyze the dominant singularities of the generating function to obtain the needed asymptotics. The paper is organized as follows. In Section 2, we recall the basic definitions and present some analytic tools. In Section 3, we study the generating function associated to regular expressions. Section 4 is devoted to our main result. Finally, a short discussion about the distribution is presented in Section 5. Note that due to the lack of space, we can not show all the details of the computations, but most of them are easily done with the help of a computeralgebra system.

2 2.1

Preliminaries Automata and Regular Expressions

An automaton defined on a finite alphabet A is a tuple (A, Q, T, I, F ) where Q is the finite set of states, T ⊂ Q × A × Q is the set of transitions, I ⊂ Q is the set of initial states and F ⊂ Q is the set of final states. We refer the reader unfamiliar with basic notions of automata and regular languages to [8] for definitions and fundamental results. The set of nonempty regular expressions R on a finite alphabet A is a set of words on the alphabet {ε, ·, ∗, ∪, (, )} ∪ A defined inductively by: ε ∈ R, A ⊂ R, (R)∗ ∈ R for all R ∈ R, (R1 ·R2 ) and (R1 ∪R2 ) for every R1 , R2 ∈ R. A language defined on A is denoted by a regular expression of R when it is exactly the set of words obtained by interpreting each symbol ∗, · or ∪ as the corresponding regular operation on sets of words. Let L(R) be the language denoted by R ∈ R. For convenience, we shall freely remove parenthesis symbols that are not needed in an element of R. It is also often useful to see regular expressions as trees, with this equivalent inductive definition: ⎧ ε∈R ⎪ ⎪ ⎪ ⎪ ⎪ a∈R ⎪ ⎪ ⎨∗ | ∈ R R ∪ ⎪ ⎪ /\ ∈ R ⎪ ⎪ ⎪ R1 R2 ⎪ • ⎪ ⎩ /\ ∈R R1 R2

∀a ∈ A ∀R ∈ R ∀R1 , R2 ∈ R

The size of an element of R is the number of  ∪ ∗  /\ | |ε| = |a| = 1;    = |R| + 1; R

(1)

∀R1 , R2 ∈ R

R1 R2

nodes in   •   /\ =

its tree representation:    = |R1 | + |R2 | + 1

R1 R2

Note that one usually add to R the symbol ∅ that denotes the empty language. For technical reasons it is slightly more convenient in this paper to work on nonempty regular languages.

628

2.2

C. Nicaud

Glushkov’s Automaton

Let m be the number of letter symbols in R, for R ∈ R. We consider the ˜ obtained from R by distinguishing the letters with subscripts in expression R {1, · · · , m}, marking them from left to right on its string representation, or equivalently using depth-first order on its tree representation. For instance R = ˜ = b∗ ·(a2 ∪b3 ·b4 )∗ . We denote by pos(R) the set of b∗ ·(a∪b·b)∗ is changed into R 1 ˜ subscripted letters in R: pos(R) = {b1 , a2 , b3 , b4 } in the example. We also denote by ν the function from pos(R) to A that removes the subscripts, ν(a2 ) = a for instance. Let F irst(R) and Last(R) be the sets defined by ˜ u starts with the letter α} F irst(R) = {α ∈ pos(R) | ∃u ∈ L(R), ˜ u ends with the letter α} Last(R) = {α ∈ pos(R) | ∃u ∈ L(R), And for any letter α in pos(R), the set f ollow(R, α) is defined by ˜ αβ is a factor of u} f ollow(R, α) = {β ∈ pos(R) | ∃u ∈ L(R), The Glushkov’s automaton of R, also called the position automaton, is the automaton AR = (A, Q, T, {i}, F ) with Q = pos(R) ∪ {i}, F = Last(R) ∪ {i} if ε ∈ L(R) and F = Last(R) otherwise, and T = {(i, ν(α), α) | α ∈ F irst(R)} ∪ {(α, ν(β), β) | β ∈ f ollow(R, α)}. This classical construction provides an automaton that recognizes L(R). Let Edges(R) be the set of pairs (α, β) ∈ pos(R)2 such that β ∈ f ollow(α). The number of transitions in AR is thus |F irst(R)| + |Edges(R)|. The set Edges(R) can also be defined inductively as follows. ⎧ ⎪ Edges(ε) = 0 ⎪ ⎪ ⎪ ⎪ ⎪ Edges(a) ⎪  ∗ = 0 ⎪ ⎨ Edges | = Edges(R) ∪ Last(R) × F irst(R) (2) R ∪  ⎪ ⎪ ⎪ = Edges(R1 ) ∪ Edges(R2 ) Edges /\ ⎪ ⎪ ⎪ R1•R2  ⎪ ⎪ ⎩Edges /\ = Edges(R1 ) ∪ Edges(R2 ) ∪ Last(R1 ) × F irst(R2 ) R1 R2

2.3

Generating Functions

A combinatorial class C is a set of objects with a size function | · | from C to N such that, for any n ∈ N, the number cn of objects of size n in C is finite. The generating function C(z) of a combinatorial class C is the formal power series C(z) =

C∈C

z |C| =



cn z n

n≥0

We also denote by [z n ]C(z) = cn the coefficient of z n in C(z).

On the Average Size of Glushkov’s Automata

629

Let C be a combinatorial class of generating function C(z) and let f : C → R be a mapping from this class to R. The cost generating function F (z) of C associated to f is F (z) = f (C)z |C| = fn z n , with fn = f (C) C∈C

n≥0

C∈C |C|=n

For a given n, the average value of f for the uniform distribution on the elements of size n of C is therefore [z n ]F (z) μn (C, f ) = n [z ]C(z) The following lemma, though trivial, will be useful throughout this article. Lemma 1. Let A and B be two combinatorial classes. Let f : A → R and g : B → R be two mappings from A and B to R. The following property holds. (f (A) + g(B))z |A| z |B| = F (z)B(z) + A(z)G(z) A∈A B∈B

where A(z), B(z), F (z) and G(z) respectively denote the generating functions of A and B and the cost generating functions associated to f and g. 2.4

Symbolic Methods and Transfer Theorem

The symbolic methods were introduced in [9]. When they can be applied, they directly and almost automatically build the generating functions associated to combinatorial classes. The idea is to avoid recurrence formulas on the number of objects by providing a dictionary that maps combinatorial constructions on classes into constructions on generating functions. This dictionary covers a lot of used constructions, and one can easily use it to describe combinatorial classes such as trees, permutations, set partitions, integer partitions, random mappings, etc. therefore obtaining directly their generating functions. In this article we shall only use a small part of this dictionary, the most basic one. If A = B ∪ C are combinatorial classes such that B and C are disjoint, it is direct to prove that the associated generating functions A(z), B(z) and C(z) satisfy A(z) = B(z) + C(z). Moreover if A = B × C, one can see that A(z) = B(z)C(z). We shall only need this two constructions here, but in this framework, one can directly derive the generating functions of sequences of elements in A, sets of elements in A, and so on. We refer the reader to P. Flajolet and R. Sedgewick’s book for more informations about this topic [7]. Once the generating function is known, either in close or implicit form, several theorems exist to compute asymptotic estimations of its coefficients. This theorems mainly use the theory of complex analysis, seeing generating functions as analytic functions from C to C. The main idea is that the asymptotics of the coefficients of a generating function can be obtained by studying it around its dominant singularities (its singularities of smallest moduli). Informally, given a

630

C. Nicaud

generating function A(z) of unique dominant singularity ρ, the transfer theorem states under some analytic conditions that if A(z) ∼ B(z) as z → ρ, then [z n ]A(z) ∼ [z n ]B(z), for some useful functions B(z) whose coefficient asymptotics are well-known. We use the notations of [7] to give a formal description of the theorem. Let R > 1 and 0 < φ < π/2 be two real numbers, the domain Δ(φ, R) is Δ(φ, R) = {z ∈ C | |z| < R, z = 1 and |Arg(z − 1)| > φ} A domain is a Δ-domain at 1 if it is a Δ(φ, R) for some R and φ. For a given complex number ζ = 0, a Δ-domain at ζ is the image by the mapping z → ζz of a Δ-domain at 1. A function is Δ-analytic if it is analytic in some Δ-domain. Theorem 1 (part of Transfer Theorem). Let α and β be real number and let f (z) be a function that is Δ-analytic that satisfies, on the intersection of a neighborhood of 1 and its Δ-domain, the condition

 β 1 f (z) = o (1 − z)−α log 1−z then [z n ]f (z) = o(nα−1 (log n)β ). Recall that Pringsheim’s Theorem states that if f (z) is representable at the origin by a series expansion with nonnegative coefficients, one of its dominant singularities, if any, is on R+ . This theorem is useful as generating functions always have nonnegative coefficients. 2.5

Analytic Tools for This Paper

The generating functions we shall study in this paper always have a unique dominant singularity, which is therefore in R+ by Pringsheim’s theorem. For any fixed alphabet size k, the dominant singularity of each generating function will always be the same ρk . Moreover, as they are all made of polynomials, quotients and square roots, their analysis have a lot of similarities. In particular, all generating functions satisfy one of the two conditions of the following proposition. Proposition 1. Let f (z) be a function that is Δ-analytic at ρ ∈ R+ . 1. If on the intersection of a neighborhood of ρ and its Δ-domain,   f (z) = a − b 1 − z/ρ + o( 1 − z/ρ), with a, b ∈ R, b =  0 then [z n ]f (z) ∼ 2√b π ρ−n n−3/2 . 2. If on the intersection of a neighborhood of ρ and its Δ-domain,

1 a +o  , with a ∈ R, a = 0 f (z) =  1 − z/ρ 1 − z/ρ then [z n ]f (z) ∼

√a ρ−n n−1/2 . π

On the Average Size of Glushkov’s Automata

631

This proposition is a direct consequence of Theorem √ 1, using classical formulas for the asymptotic of the coefficients of z → 1 − z and z → (1 − z)−1/2 . If f (z) is a function which is Δ-analytic at ρ ∈ R+ , we say that f satisfies the property Π1 or Π2 at ρ if it satisfies the first or second condition of Proposition 1 respectively. The computations involved here can be technical, but can be done almost automatically (with the help of computer algebra software for the most complex ones). It is always straightforward to check that this functions satisfy the analytic conditions of Proposition 1. The value of a (and b) can also be computed, and will be some functions of the size of the alphabet. In the rest of the paper, due to the lack of space, most details of the computations will be omitted.

3

Generating Functions for Regular Expressions

In this section we apply the framework of analytic combinatorics to the classes of regular expressions we are studying. From now on, the alphabet considered is A = {a1 , . . . , ak }, where k ≥ 1 is a positive integer. 3.1

General Regular Expressions

From Equation (1), one can use the symbolic method to obtain the following specification ∗ • ∪ R = ε + a1 + · · · + ak + | + /\ + /\ R

RR

RR

And therefore, using the dictionary, one obtain the following equation for R(z), the generating function associated to R: R(z) = (k + 1)z + zR(z) + 2zR2 (z) From which one can derive the following expression for R(z), using the fact that its Taylor coefficients are nonnegative:  1 − z − Δk (z) R(z) = , with Δk (z) = 1 − 2z − (7 + 8k)z 2 4z √

2k+2−1 The unique dominant singularity of R(z) is ρk = 2 7+8k , and around ρk , one has the following expansion of R(z)

 1 1 − ρk 1  z 2 R(z) = − Δk (z) + o 1− 4ρk 4ρk ρk

  √  1 1 2(1 − ρk ) 2k + 2 z 2 z 2 − +o 1− R(z) = 1− 2 4ρk ρk ρk

therefore, using Proposition 1, one can obtain an asymptotic equivalent to the number of nonempty regular expressions. Lemma 2. The number of √ elements of size n in R is asymptotically equivalent 2(1−ρ ) −n −3/2 , with Ck = 8ρk √πk . to Ck ρk n

632

C. Nicaud

Note that if some generating function f (z) has a unique dominant singularity on ρk where we can apply Proposition 1, and satisfies as z → ρk : f (z) = a −

 b  Δk (z) + o( 1 − z/ρk ) 4ρk

it is  often more then [z n ]f (z) ∼ b [z n ]R(z). Therefore, for our computations,  convenient to obtain developments in terms of 4ρ1k Δk (z) instead of 1 − z/ρk . The techniques are of course the same, since they only differ by a multiplicative constant as z → ρk . 3.2

Regular Expressions of Languages Containing ε

Denote by Rε and Rε the regular expressions whose associated languages respectively recognize and do not recognize the empty word. A specification of Rε is the following: • ∪ ∪ ∗ Rε = ε + | + /\ + /\ + /\ (3) R

Rε R

Rε Rε

Rε Rε

From which one can obtain the following expression: Rε (z) =

z + zR(z) 1 − 2zR(z)

The dominant singularity of Rε (z) is also ρk and it satisfies Π1 at ρk :

  √ √ 1 2k + 2k + 2 1 − 2k + 4k 2k + 2 Δk (z) z 2 Rε (z) = − +o 1− 4k + 2 (2k + 1)2 4ρk ρk Therefore, using Proposition 1 one can obtain an asymptotic equivalent to its coefficients: √ 1 − 2k + 4k 2k + 2 [z n ]Rε (z) ∼ Dk [z n ]R(z), with Dk = (4) (2k + 1)2 Note that, as a consequence, the ratio of regular expressions whose denoted language contains the empty word is asymptotically Dk . For a two-letters alphabet, the value of Dk is approximatively D2 ≈ 0.664.

4

Main Result

This section is devoted to the proof of our main theorem: Theorem 2. The average number of transitions of the Glushkov’s automaton associated to a regular expression of size n, for the uniform distribution, is in Θ(n). 4.1

Lower Bound

First remark that if an expression R ∈ R contains m letters, then its Glushkov’s automaton has m + 1 states. Moreover, since it is accessible by construction, it has at least m transitions. For R ∈ R, let (R) be the number of letters in R.

On the Average Size of Glushkov’s Automata

633

Let L(z) be the cost generating function of the number of letters in an element R of R: L(z) = (R)z |R| R∈R

From Equation (1) and Lemma 1, we have L(z) = kz + zL(z) + 2zL(z)R(z) + 2zL(z)R(z)  Hence, using the fact that 1 − z − 4zR(z) = Δk (z): kz L(z) =  Δk (z) Therefore, L(z) has a unique dominant singularity at ρk and satisfy Π2 at ρk . By Proposition 1, kρk −1/2 ρ−n [z n ]L(z) ∼  k n 2π(1 − ρk ) and the average number of letters in an element of size n of R is equivalent to 4kρ2k 4kρ2k 1−ρk n as n → ∞. For k = 2, an approximation of 1−ρk is 0.408. We conclude that in average, the number of transitions in the Glushkov’s automaton of an element of size n of R is in Ω(n). 4.2

Outline of the Proof of the Upper Bound

In the following subsections we establish some results used to compute an upper bound for the average number of transitions in a Glushkov’s automaton. As stated before, the size of the Glushkov’s automaton associated to a nonempty regular expression R ∈ R is equal to the number of elements in F irst(R) plus the number of elements in Edges(R). In the next subsection we prove that in average, the size of F irst(R) tends towards a constant. For the remaining part, we actually compute an upper bound of the size of Edges(R), not its exact average cardinality. Define the function e : R −→ N by: ⎧ ⎪ e(ε) = 0 ⎪ ⎪ ⎪ ⎪ ⎪ e(a) = 0 ∀a ∈ A ⎪ ⎪ ⎨ ∗ | e = e(R) + |Last(R)| · |F irst(R)| ∀R ∈ R (5) R ∪  ⎪ ⎪ ⎪e /\ = e(R ) + e(R ) ∀R , R ∈ R ⎪ 1 2 1 2 ⎪ ⎪ ⎪ R1•R2  ⎪ ⎩e /\ = e(R1 ) + e(R2 ) + |Last(R1 )| · |F irst(R2 )| ∀R1 , R2 ∈ R R1 R2

Clearly e(R) is an upper bound of |Edges(R)|, since its definition is obtained from the one of Edges, Equation (2), and the inequality |X ∪ Y | ≤ |X| + |Y |. Let E(z) and F (z) be the cost generating functions of e and |F irst(·)| respectively, and let P (z) be the following generating function P (z) = |F irst(R)| · |Last(R)|z |R| R∈R

634

C. Nicaud

Note that, by symmetry, F (z) is also the cost generating function of last, F (z) =  |R| . R∈R last(R)z Using Equation (5) and Lemma 1, one has E(z) = zE(z) + zP (z) + 2zR(z)E(z) + 2zR(z)E(z) + zF (z)2 hence (1 − z − 4zR(z))E(z) = zP (z) + zF (z)2  and as 1 − z − 4zR(z) = Δk (z), we finally obtain E(z) =

zP (z) + zF (z)2  Δk (z)

(6)

At this point we need more informations about P (z) and F (z) in order to conclude that [z n ]E(z) = n O([z n ]R(z)). They will be obtained in the next subsections. 4.3

The Cost Generating Function F (z)

For an element R ∈ R, let first(R) and last(R) denote respectively the cardinalities of the sets F irst(R) and Last(R). We analyze the average value of first(R), for a regular expression R ∈ R of size n. F (z) is the cost generating function of first, and we also consider its restrictions Fε (z) to Rε and Fε (z) to Rε : Fε (z) = first(R)z |R| ; Fε (z) = first(R)z |R| R∈Rε

R∈Rε

For a given R ∈ R, the value of first(R) can be computed inductively as ⎧ ⎪ first(ε) = 0; ⎪ ⎪ ⎪ ⎪ ⎪ first(a) ∀a ∈ A ⎪  ∗ = 1 ⎪ ⎪ ⎪ ⎪ ∀R ∈ R ⎨first R| = first(R)  ∪  (7) first /\ = first(R1 ) + first(R2 ) ∀R1 , R2 ∈ R ⎪ ⎪ R R 1 2 ⎪  •  ⎪ ⎪ ⎪ = first(R1 ) + first(R2 ) ∀R1 ∈ Rε , ∀R2 ∈ R first /\ ⎪ ⎪ ⎪ R1•R2  ⎪ ⎪ ⎩first /\ = first(R1 ) ∀R1 ∈ Rε , ∀R2 ∈ R R1 R2

We consider the following specification of R R = ε + a1 + · · · + ak +

∗ | R

+

∪ /\ RR

+

• /\ Rε R

+

• /\ Rε R

This specification can be transformed into a functional equation on cost generating functions using Lemma 1 and Equation (7). For instance, the construction • /\ Rε R

z

produces the term:





(first(R1 ) + first(R2 ))z |R1 | z |R2 | = zRε (z)F (z) + zFε (z)R(z)

R1 ∈Rε R2 ∈R

On the Average Size of Glushkov’s Automata

635

All computations and simplifications done, we obtain: F (z) =

kz 1 − z − 3zR(z) − zRε (z)

As R(z) and Rε (z) are known, it is straightforward to obtain the expansion of F (z) near its dominant singularity ρk and to check that it satisfies Π1 at ρk :

  1 Δk (z) z 2 F (z) = Ek − Fk +o 1− (8) 4ρk ρk √ √ 2k+2 with Ek = 1 + 2k + 2 and Fk = 12+6k+8 . Hence, using Proposition 1, k one can prove the following proposition.

Proposition 2. For any fix integer k ≥ 1, the average size of first tends √ 12+6k+8 2k+2 toward a constant Fk = , as n tends toward infinity: [z n ]F (z) ∼ k n Fk [z ]R(z). For k = 2, an approximation of Fk is F2 ≈ 21.8. 4.4

The Cost Generating Function Fε (z)

Similarly, one can use the specification of Rε of Equation (3) to compute Fε (z). We obtain zF (z) + 2zRε (z)F (z) Fε (z) = 1 − 2zR(z) Once again, Fε (z) satisfies Π1 at ρk with  √  Δk (z) 4k + 1 + 2k + 2 + o( Δk (z)), with Gk = Fε (z) = Gk − Hk 4ρk 2k + 1 The expression of Hk > 0 in terms of k can also be computed, but is not needed in the following. 4.5

The Cost Generating Function of the Product first × last

We analyze the average value of the product of first(R) and last(R), for a regular expression R ∈ R of size n. We consider the cost generating function P (z) of this product, and its restriction Pε (z) to Rε and Pε (z) = P (z) − Pε (z) to Rε : Pε (z) = first(R) · last(R)z |R| ; Pε (z) = first(R) · last(R)z |R| R∈Rε

R∈Rε

We use the following specification of R: R = ε + a1 + · · · + ak +

∗ | R

+

∪ /\ RR

+

• /\ Rε Rε

+

• /\ Rε Rε

+

• /\ Rε Rε

+

• /\ Rε Rε

636

C. Nicaud

The cost generating function associated to each term of the specification is com• puted separately. For instance, one has the following cost function for /\ :



first

R1 ∈Rε R2 ∈Rε

=z

 •  •  /\ last /\ z 1+|R1 |+|R2 | R1 R2 R1 R2







Rε Rε

(first(R1 ) + first(R2 )) last(R2 )z |R1 | z |R2 |

R1 ∈Rε R2 ∈Rε

=z





first(R1 )last(R2 )z |R1 | z |R2 | + zRε (z)Pε (z)

R1 ∈Rε R2 ∈Rε

= zFε (z)Fε (z) + zRε (z)Pε (z) Using the same techniques for the other parts of the expression, we obtain: P (z) =

kz + 3zF (z)2 + zFε (z)2 1 − z − 2zR(z) − 2zRε (z)

From which, using the previous results, we conclude that P (z) satisfies Π1 at ρk and that there exists some real numbers Ik and Jk such that, as z → ρk ,   P (z) = Ik − Jk Δk (z) + o( Δk (z)) with Ik = 4.6

√ 38k2 +77k+28+(14k2 +45k+20) 2k+2 2k(k+1)

and Jk > 0.

Concluding the Proof of Theorem 2

We can now analyze Equation (6). As both F (z) and P (z) satisfy Π1 , so does zP (z) + zF (z)2 , since the constant term of its development near ρk is not zero. Hence E(z) satisfies Π2 at ρk and Proposition 1 can be applied: [z n ]E(z) ∼ ek n [z n ]R(z) The value of ek is not needed to prove the theorem, but is still an indication on a bound of the average number of transitions in a Glushkov’s automaton: √ 32k 4 + 204k 3 + 406k 2 + 306k + 72 + (80k 3 + 230k 2 + 193k + 52) 2k + 2 ek = 2k(k + 1)(2k + 1)(8k + 7) For k = 2, an approximation of ek is e2 ≈ 6.77. The quantity [z n ]E(z)/[z n ]R(z) is an upper bound of the average cardinality of Edges and the average cardinality of F irst is bounded by Proposition 2, therefore, by linearity of the average, the average number of transitions in a Glushkov’s automaton is in O(n). This concludes the proof of Theorem 2.

5

Remarks

In this paper we used the specification of regular expressions that directly follows the inductive definition. One could try to use a more precise specification to

On the Average Size of Glushkov’s Automata

637

prevent some useless patterns in regular expressions to appear, as was done for instance in [10] for enumeration purposes. Depending on the chosen such rules, the analysis we conduct here could still be doable, but probably much more complicated. Especially if the specification is not context-free (see [11] for a related analysis). However, we believe that the result would be the same in much cases. Indeed, the proofs of Theorem 2 and Proposition 2 are based on the fact that for a non-negligible proportion of regular expressions, the denoted language does not recognize the empty word, and that the average number of concatenation operators is non-negligible. This must be true for most natural specifications. Also note that we could have used bivariate generating functions instead of cost generating functions in this paper. The computations would have been the same here, but this approach should be useful if one want to go one step further, and try to obtain some informations not only about the average value, but also about the limit distribution.

References 1. Sakarovitch, J.: The language, the expression, and the (Small) automaton. In: Farr´e, J., Litovsky, I., Schmitz, S. (eds.) CIAA 2005. LNCS, vol. 3845, pp. 15–30. Springer, Heidelberg (2006) 2. Glushkov, V.M.: The abstract theory of automata. Russian Math. Surveys 16, 1–53 (1961) 3. Hromkovic, J., Seibert, S., Wilke, T.: Translating regular expressions into small epsilon-free nondeterministic finite automata. In: Reischuk, R., Morvan, M. (eds.) STACS 1997. LNCS, vol. 1200, pp. 55–66. Springer, Heidelberg (1997) 4. Hagenah, C., Muscholl, A.: Computing epsilon-free NFA from regular expressions in O(n log2 (n)) time. ITA 34(4), 257–278 (2000) 5. Ilie, L., Yu, S.: Constructing N F As by optimal use of positions in regular expressions. In: Apostolico, A., Takeda, M. (eds.) CPM 2002. LNCS, vol. 2373, pp. 279–288. Springer, Heidelberg (2002) 6. Champarnaud, J.M., Nicart, F., Ziadi, D.: Computing the follow automaton of an expression. In: Domaratzki, M., Okhotin, A., Salomaa, K., Yu, S. (eds.) CIAA 2004. LNCS, vol. 3317, pp. 90–101. Springer, Heidelberg (2005) 7. Flajolet, P., Sedgewick, R.: Analytic Combinatorics. Cambridge University Press, Cambridge (2008) 8. Hopcroft, J.E., Ullman, J.D.: Introduction to Automata Theory, Languages, and Computation. Addison-Wesley, Reading (1979) 9. Flajolet, P., Odlyzko, A.M.: The average height of binary trees and other simple trees. J. Comput. Syst. Sci. 25(2), 171–213 (1982) 10. Lee, J., Shallit, J.: Enumerating regular expressions and their languages. In: Domaratzki, M., Okhotin, A., Salomaa, K., Yu, S. (eds.) CIAA 2004. LNCS, vol. 3317, pp. 2–22. Springer, Heidelberg (2005) 11. Fern´ andez-Camacho, M.I., Steyaert, J.M.: Algebraic simplification in computer algebra: An analysis of bottom-up algorithms. TCS 74(3), 273–298 (1990)

Tiling the Plane with a Fixed Number of Polyominoes Nicolas Ollinger Laboratoire d’informatique fondamentale de Marseille (LIF), Aix-Marseille Universit´e, CNRS, 39 rue Joliot-Curie, 13 013 Marseille, France [email protected]

Abstract. Deciding whether a finite set of polyominoes tiles the plane is undecidable by reduction from the Domino problem. In this paper, we prove that the problem remains undecidable if the set of instances is restricted to sets of 5 polyominoes. In the case of tiling by translations only, we prove that the problem is undecidable for sets of 11 polyominoes.

Introduction Tiling the plane given a finite set of tiles is an old and fascinating problem. For an survey on tilings, the reader is invited to consult Gr¨ unbaum and Shephard [1]. A celebrated computability result by Berger [2] is the undecidability of the Domino problem: given a finite set of Wang tiles, unit squares with colored edges, decide if the Wang tiles can tile the whole plane so that matching edges share a same color. A polyomino is a simple kind of tile: it consists of rookwise connected unit squares. Golomb [3] studied tiling by polyominoes and proved in [4] that the Domino problem can be reduced to deciding if a finite set of polyominoes tiles the plane. The reduction can be achieved by a classical encoding of Wang tiles by polyominoes that preserves tilings. In this reduction, the number of polyominoes is equal to the initial number of Wang tiles. A natural question arises: what happens if we consider the tiling problem for a fixed number of polyominoes? From this previous result, two cases might happen: (1) the problem is undecidable starting from a certain fixed number of polyominoes (2) the problem is decidable for every fixed number of polyominoes but the family of decision procedures is not itself recursive. As case (1) is more likely to happen, the question is to find the frontier between decidability and undecidability. Such a study of decidability questions with respect to a parameter appears for example in the study of semi-Thue systems or for Post correspondence problem (PCP) where it is shown that P CP (2) is decidable and P CP (7) is undecidable [5,6,7]. Motivated by parallel computing, Wijshoff and van Leeuwen [8] proved that the tilability of the plane by translation of a unique polyomino is decidable. That result was further studied and understood by Beauquier and Nivat [9] who described precisely the tilings by translation generated by a unique polyomino. This paper is organized as follows. In section 1, we introduce Wang tiles, polyominoes and dented polyominoes, a special variation of polyominoes used in A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 638–647, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Tiling the Plane with a Fixed Number of Polyominoes

639

the constructions. In section 2, we prove that it is undecidable whether a set of 5 polyominoes tiles the plane. In section 3, we deduce from previous section that it is undecidable whether a set of 11 polyominoes tiles the plane by translation. In section 4, we discuss the case of smaller sets of tiles.

1

Definitions

Polyominoes. A polyomino is a simply connected tile obtained by gluing together rookwise connected unit squares. A tiling, of the Euclidian plane, by a set of polyominoes is a partition of the plane such that each element of the partition is the image by an isometry of a polyomino of the set. A tiling by translation is a tiling where isometries are restricted to translations. A tiling is periodic if it is invariant by translation, biperiodic if it is invariant by two non-colinear translations, aperiodic if it is not periodic. A set of polyominoes is aperiodic if it admits a tiling and all its tilings are aperiodic. A tiling is discrete if all the vertices of the unit squares composing the polyominoes are aligned on the grid Z2. If a tiling is not discrete, the tiling can be split into two tilings of a half-plane along a line going through an edge along which two unit squares are not aligned. By shifting one half-plane to align the tiles, and iterating this process, one obtains the following lemma. Lemma 1. A set of polyominoes admits a tiling if and only if it admits a discrete tiling. In this paper where we deal with tilability, we only consider discrete tilings, thanks to this lemma. Thus, a polyomino can be considered as a finite, simply connected, subset of Z2 and a tiling by a set of polyominoes is a partition of Z2 where each element is the image by an isometry of an element of the set. Each such isometry can be decomposed into a translation and one out of 8 elementary transformations obtained by composing right angle rotations and mirroring. A sample polyomino and its 8 transformations are represented in Fig. 1.

Fig. 1. A polyomino and its 8 transformations

Polyominoes are compactly described by their contour words. A contour word of a polyomino is a (finite) word on the alphabet {e, w, n, s} describing a walk along the outline of the polyomino starting from and ending to a vertex of the boundary of the polyomino where e is an east move (1, 0), w is a west move

640

N. Ollinger

(−1, 0), n is a north move (0, 1) and s is a south move (0, −1). A word is a contour word if and only if the associated path does not cross itself. A polyomino with a pointed contour word is represented in Fig. 2

e3 ne2 se2 n2 w5 swnws2 Fig. 2. A polyomino with a pointed contour word

Wang Tiles. A Wang tile is a unit square with colored edges. A tiling by a set of Wang tiles is a discrete tiling by tiles of the set such that along each edge the colors match on both sides. The Domino problem is the following decision problem: given a finite set of Wang tiles, decide whether it admits a tiling. Theorem 1 (Berger [2]). The Domino problem is undecidable. The Polyomino problem is the following decision problem: given a finite set of polyominoes, decide whether it admits a tiling. By a reduction from the Domino problem to the Polyomino problem, Golomb [4] proved the undecidability of the Polyomino problem. Theorem 2 (Golomb [4]). The Polyomino problem is undecidable. The reduction proceeds as follows. Given a finite set of Wang tiles, Golomb encodes each tile into a big squarish polyomino. Special bumps and dents are added to the corners of the tiles to force both alignment and orientation of the tiles: if one of the encoding polyominoes appears with an orientation, all the other tiles of the tiling have to use the same orientation. Special bumps and dents are used along the sides of the big polyominoes to encode the colors of the Wang tiles. Quotienting the set of tilings of the set of encoding polyominoes by isometries, it is in bijection with the set of tilings of the given set of Wang tiles. Dented Polyominoes. A dented polyomino is a polyomino with edges labeled by a shape and an orientation. The four possible orientations {p, q, b, d} and their interpretation depending on the direction of the edge are depicted on Table 1 for a sample shape. On a contour word, inside shapes define bumps and outside shapes define dents. A tiling by a set of dented polyominoes is a tiling by the corresponding set of polyominoes where bumps and dents match along edges. Dented polyominoes provide a convenient tool to construct complicated sets of polyominoes. These polyominoes with puzzle bumps and dents can be easily converted into polyominoes. Lemma 2. Every finite set of dented polyominoes can be encoded as a finite set of polyominoes such that their sets of tilings are in one-to-one correspondence.

Tiling the Plane with a Fixed Number of Polyominoes

641

Table 1. Encoding of bumps and dents orientation

p

q

b

d

e w n s Proof. In order to guarantee that bumps and dents do not interfere with the matching conditions of polyominoes, the idea is to rescale the polyominoes. For all k ∈ Z+ , a k-rescaling of a set of polyominoes consists into scaling the polyominoes by a factor k, i.e., replacing each unit square by a square of k by k unit squares. Tilings are preserved by rescaling: the set of tilings of a set of polyominoes is in one-to-one correspondence with the set of tilings of its k-rescaling. To encode a finite set of dented polyominoes into a finite set of polyominoes: first, rescale the set of polyominoes by a factor far bigger than the size of any shape of its bumps and dents; then, add bumps and dents in the middle of each rescaled edge.  

2

Tiling with a Fixed Number of Polyominoes

The k-Polyomino problem is the following decision problem: given a set of k polyominoes, decide whether it admits a tiling. This section is dedicated to the proof of the following theorem. Theorem 3. The 5-Polyomino problem is undecidable. We will proceed by reduction of the Domino problem. Given a finite set τ of Wang tiles, we construct a set of 5 dented polyominoes P (τ ) such that, up to isometry, the set of tilings of τ is in one-to-one correspondence with the set of tilings of P (τ ). The proof goes as follows. First, we describe the construction of P (τ ). Then, we explain how to encode any tiling of τ by a tiling of P (τ ). Finally, we show that any tiling of P (τ ) encodes a tiling of τ . 2.1

Encoding a Set of Wang Tiles

Let τ be a set of N Wang tiles. The set of dented polyominoes P (τ ) consists of the following 5 tiles, represented in Fig. 3: meat encodes all tiles of the set τ sequentially; jaw acts as a selector to select exactly one tile of the meat ; filler is used for padding the blank leaved by the meat inside the jaw ; tooth erases the bits on the meat so that it fits inside the jaw ; wire links meat pieces together to verify tiling constraints.

642

N. Ollinger

From left to right and bottom to top : meat, tooth, wire, filler, jaw Notice that here N = 4 and k = 3 to fit the page (in the text k > 4). Fig. 3. Tiles (rotated to fit in page)

Tiling the Plane with a Fixed Number of Polyominoes

643

More formally, the dented polyominoes use 4 different shapes for bumps and dents, detailed on Table 2. Table 2. Types of bumps and dents blank shape notation order bump dent

1

bit

marker

inside

b m i 4 4 2 wire, tooth meat, filler tooth, filler meat jaw jaw

Let k be a large enough integer and choose an encoding on k − 4 bits of the colors of the set of Wang tiles (horizontal and vertical colors can use different encodings). Let (aij ), (bij ), (cij ), (dij ) be respectively the north, east, south, and west binary encoding of the tiles where i is the tile index from 1 to N and j is the bit index from 1 to k − 4. Let (aij ) be the encoding of the k bits, by adding prefix 00 and suffix 01, of (aij ) on the alphabet {b, d}. Let (bij ) be the encoding of the k bits, by adding prefix 10 and suffix 11, of (bij ) on the alphabet {p, q}. Let (cij ) be the encoding of the k bits, by adding prefix 00 and suffix 01, of (cij ) on the alphabet {b, d}. Let (dij ) be the encoding of the k bits, by adding prefix 10 and suffix 11, of (dij ) on the alphabet {p, q}. The dented polyominoes are given by their contour words on Table 3. Table 3. Contour encoding of the tiles tooth: ebi nwbq s wire: ebb n5 w2N(k+1)+1 n4 wbp s5 e2N(k+1)+1 s4  k  b k d q p filler : ebm sebi (nwip )k (wip s)k wm s ei n em nwm  N−1   d k  d k b N−1 d 4 2(N−1)(2k+2)+4 4 d jaw : eqm epm (nepi )k (epi s)k eqm s wm wm s e n swi wi n wm     N−1  d k  d k b N−1 b d wm wm n epm (nepi )k (epi s)k eqm epm n4 w2(N−1)(2k+2)+4 s4 swi wi n wm   i   i   i i N   a b a b k−1 b eb j s eb k k−1 eb j n eb k edm n meat: i=1 em j=1 j=1   i   i   1 2 cj d c i1 2 di p q wm wb j s wb 1 wm s i=N j=k wb n wb j=k

Notice the following important properties of these tiles. The meat consists of a sequence of N diamonds decorated with bit shapes with a prefix and a suffix marker shape pointing to the diamond. If one connects a tooth in each bit dent of a diamond of the meat , the diamond becomes similar to the filler. Moreover, both inside parts of a jaw consists of N − 1 places to put a filler plus a marker shape at the entry of the jaw , pointing outside.

644

2.2

N. Ollinger

Encoding Tilings by Wang Tiles

Let us first prove the following lemma. Lemma 3. Every tiling by τ can be encoded as a tiling by P (τ ). The set of dented polyominoes is designed to encode a Wang tile by selecting one diamond of a meat, hiding the other diamonds using two jaws on the left and the right, padding inside the jaws with teeth and fillers, as represented in Fig. 4. The colors of the tile are propagated to the four neighbor tiles using wires.

Fig. 4. Encoding of a Wang tile including inter-tiles wires 2

Let T ∈ τ Z be a tiling by τ . Each north-west diagonal (x + y = i for the ith diagonal) is encoded as a line of Wang tile encodings where a jaw connects tile T (x, i − x) to tile T (x + 1, i − x − 1). These lines of encoding are put on top of each other with a slight translation so that tile T (x, i − x) is connected by wires to T (x + 1, i − x), T (x, i − x + 1), T (x − 1, i − x) and T (x, i − x − 1), as represented in Fig. 5. Notice that the choices made for a, b, c, and d permits such a connection only if the Wang tiling is valid. Thus, one obtains a tiling of the dented polyominoes.

Fig. 5. Wiring of Wang tiles

Tiling the Plane with a Fixed Number of Polyominoes

2.3

645

Every Tiling Encodes a Tiling

Now, we prove the following lemma. Lemma 4. Every tiling by P (τ ) encodes a tiling by τ . Consider a tiling by the dented polyominoes. We first show that it must contain a jaw. Consider any tile of the tiling. If it is a jaw, we are done. Examine Table 2. If it is a meat or a filler, it has a marker bump that should be linked to a dent only found on a jaw. If it is a tooth, it has an inside bump that should be linked to a dent only found on a jaw. Finally, if it is a wire, it has bit bump that should be linked to a meat, itself connected to a jaw. Consider a jaw tile of the tiling. To fill all the marker bumps, only filler and meat tiles can be used. As fillers have inside bumps, they can only be used completely inside the jaw. Thus, the markers on the extremities of the jaw have to be filled by the dents of a meat. Consider the meat that fills a marker at the extremity of the jaw. As marker bumps only appear inside jaws, the marker dent on the other side of the diamond of the meat next to the jaw has to be at the extremity of a next jaw. The only possibility to fill the gap in between the jaw and the meat locking its extremity is to use fillers and teeth. By now, we have proved that each jaw of the tiling appears in a biinfinite line (or column if rotated) of alternating jaws and meats where each meat has exactly one selected diamond outside the jaws. Consider now the diamond of each meat appearing outside the jaws: it has bit bumps. A bit dent is found only on teeth and wires. As a tooth cannot appear outside a jaw (it as an inside dent), only wires can be connected to these bumps. Consider the two bit bumps side by side at the top of the diamond hill. The only possibility for two wires to appear side by side is to have the left one point to the left and the right one point to the right. This enforces all the wires in between the jaw and the top hill wire to point in the same direction: left ones to the left and right ones to the right. Thus, every tiling by dented polyominoes consists of biinfinite lines (or columns) of selected meat diamonds connected by wires in a lattice way as on Fig. 5. Due to isometries, it remains to prove that all the selected diamonds have the same orientation. This part is enforced by the prefix/suffix trick in the a, b, c, and d encoding: the only possibility for a diamond to be connected to another diamond is that prefix and suffix match, thus both should be oriented in the same way. Thus, the tiling is the image by an isometry of a tiling by Wang tiles. We have proved that every tiling by P (τ ) encodes a tiling by τ , achieving the reduction.

3

Tiling by Translation

The k-Polyomino translation problem is the following decision problem: given a set of k polyominoes, decide if it admits a tiling by translation. Using the result of previous section, one obtains the following.

646

N. Ollinger

Theorem 4. The 11-Polyomino translation problem is undecidable. To prove this theorem, for any finite set of Wang tiles τ , construct a set of 11 polyominoes as follows. Consider the set of 5 dented polyominoes P (τ ). To encode any tiling by τ into a tiling by P (τ ) as done in the previous section, we use exactly: 1 1 1 4 4

transformation of meat ; transformation of jaw ; transformation of filler ; transformations of wire; transformations of tooth.

The set of 11 polyominoes tiling by translation consists exactly of these tile transformations. These dented polyominoes admit a tiling if and only if the set of Wang tiles admits a tiling.

4

Going Further

What can be said about tilability for sets of less that 5 polyominoes? or less than 11 polyominoes for tilings by translation? In the case of 1 polyomino, it is decidable for tiling by translation and still open for tiling with isometries. Theorem 5 (Wijshoff and van Leeuwen [8], Gambini and Vuillon [10]). The 1-Polyomino translation problem is decidable in time quadratic in the size of the contour word. Open Problem 1. Is the 1-Polyomino problem decidable? To prove the undecidability of the Polyomino problem, one has to be able to construct aperiodic sets of polyominoes. Ammann et al provide a set of 2 polygonal tiles with colors and 3 polygonal tiles with bumps and dents that admits only aperiodic tilings. This set is convertible into polyominoes. Theorem 6 (Ammann et al. [11]). There exists an aperiodic set of 3 polyominoes. Theorem 7 (Ammann et al. [11]). There exists an aperiodic set of 8 polyominoes for tiling by translation. Open Problem 2. Is the k-Polyomino problem decidable for 3  k < 5? Open Problem 3. For 8  k < 11, is the k-Polyomino translation problem decidable?

Acknowledgement The author thanks Bruno Durand for challenging him with the decision problem of tiling the plane with a fixed number of polyominoes.

Tiling the Plane with a Fixed Number of Polyominoes

647

References 1. Gr¨ unbaum, B., Shephard, G.C.: Tilings and patterns. A Series of Books in the Mathematical Sciences. W. H. Freeman and Company, New York (1989) 2. Berger, R.: The undecidability of the domino problem. Memoirs American Mathematical Society 66 (1966) 3. Golomb, S.W.: Tiling with polyominoes. Journal of Combinatorial Theory 1(2), 280–296 (1966) 4. Golomb, S.W.: Tiling with sets of polyominoes. Journal of Combinatorial Theory 9(1), 60–71 (1970) 5. Post, E.L.: A variant of a recursively unsolvable problem. Bulletin of the American Mathematical Society 52, 264–268 (1946) 6. Claus, V.: Some remarks on PCP(k) and related problems. Bulletin of the EATCS 12, 54–61 (1980) 7. Matiyasevich, Y., S´enizergues, G.: Decision problems for semi-thue systems with a few rules. Theoretical Computer Science 330(1), 145–169 (2005) 8. Wijshoff, H.A.G., van Leeuwen, J.: Arbitrary versus periodic storage schemes and tessellations of the plane using one type of polyomino. Information and Control 62(1), 1–25 (1984) 9. Beauquier, D., Nivat, M.: On translating one polyomino to tile the plane. Discrete and Computational Geometry 6(1), 575–592 (1991) 10. Gambini, I., Vuillon, L.: An algorithm for deciding if a polyomino tiles the plane. Theoretical Informatics and Applications 41(2), 147–155 (2007) 11. Ammann, R., Gr¨ unbaum, B., Shephard, G.: Aperiodic tiles. Discrete and Computational Geometry 8(1), 1–25 (1992)

New Morphic Characterizations of Languages in Chomsky Hierarchy Using Insertion and Locality Kaoru Onodera Department of Information Sciences, School of Science and Engineering, Tokyo Denki University, Ishizaka, Hatoyama-machi, Hiki-gun, Saitama 350-0394, Japan [email protected]

Abstract. In this paper, we obtain some characterizations and representation theorems of languages in Chomsky hierarchy by using insertion systems, strictly locally testable languages, and morphisms. For instance, each recursively enumerable language L can be represented in the form L = h(L(γ) ∩ R), where γ is an insertion system of weight (3, 3), R is a strictly 2-testable language, and h is a projection. A similar representation can be obtained for context-free languages, using insertion systems of weight (3, 0) and strictly 4-testable languages, as well as for regular languages, using insertion systems of weight (1, 0) and strictly 2-testable languages.

1

Introduction

DNA computing theory involves the use of insertion and deletion operations. It has been shown that by using insertion and deletion operations, any recursively enumerable language can be characterized in [1], [2]. Insertion systems in which we can use only insertion operations are somewhat intermediate between Chomsky context-sensitive grammars (nonterminal symbols are rewritten according to specified contexts) and Marcus contextual grammars (contexts are adjoined to specified strings associated with contexts). From the definition of insertion operations, one would easily imagine that by using only insertion operations, we generate only context-sensitive languages. On the other hand, the class of strictly locally testable languages is known as a proper subclass of regular language classes [3]. The equivalence relation between a certain type of splicing languages and strictly locally testable languages is known [4]. We focus on characterizing recursively enumerable languages by using insertion systems together with some “additional mechanisms”. It has been shown that using insertion systems together with some morphisms, characterizing recursively enumerable languages is accomplished in [2], [5], [6]. Each recursively enumerable language L can be represented in a similar way to the well-known Chomsky-Sch¨ utzenberger representation of context-free languages, L = h(L(γ) ∩D), where γ is an insertion system, h is a projection, and D is a Dyck language [7]. In this paper, we use strictly locally testable languages and morphisms as the additional mechanisms for characterizing recursively enumerable languages. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 648–659, 2009. c Springer-Verlag Berlin Heidelberg 2009 

New Morphic Characterizations of Languages in Chomsky Hierarchy

649

In insertion systems, a pair of the maximum length of inserted strings and the one of context-checking strings, called weight is an important parameter for generative powers. As for strictly locally testable languages, the length of local testability-checking is considered. We prove that each recursively enumerable language can be represented in the form h(L(γ) ∩ R), where γ is an insertion system of weight (3, 3), h is a morphism, and R is a strictly 2-testable language. The similar characterizations are shown for context-free and regular languages. The optimality of these results, in terms of weight in insertion operations and the parameter of strictly locally testable languages remains to be checked.

2

Preliminaries

In this section, we introduce necessary notation and basic definitions needed in this paper. We assume the reader to be familiar with the rudiments on basic notions in formal language theory (see, e.g., [2,8]). 2.1

Basic Definitions

For an alphabet V , V ∗ is the set of all strings of symbols from V which includes the empty string λ. For a string x ∈ V ∗ , |x| denotes the length of x. For 0 ≤ k ≤ |x|, let P rek (x) and Sufk (x) be the prefix and the suffix of x of length k, respectively. For 0 ≤ k ≤ |x|, let Intk (x) be the set of proper interior substrings of x of length k, while if |x| = k then Intk (x) = ∅. 2.2

Normal Forms of Grammars

A phrase structure grammar is a quadruple G = (N, T, P, S), where N is a set of nonterminal symbols, T is a set of terminal symbols, P is a set of production rules, and S in N is the initial symbol. A rule in P is of the form r : α → β, where α ∈ (N ∪ T )∗ N (N ∪ T )∗ , β ∈ (N ∪ T )∗ , and r is a label from a given set Lab(P ) such that there are no production rules with the same label. For any x and y in r (N ∪ T )∗ , if x = uαv, y = uβv, and r : α → β ∈ P , then we write x =⇒G y. We say that x directly derives y with respect to G. If there is no confusion, we write x =⇒ y. The reflexive and transitive closure of =⇒ is denoted by =⇒∗ . We define a language L(G) generated by a grammar G as follows: L(G) = {w ∈ T ∗ | S =⇒∗G w}. It is well known that the class of languages generated by the phrase structure grammars is equal to the class of recursively enumerable languages RE [8]. A grammar G = (N, T, P, S) is context-free if P is a finite set of context-free rules of the form A → α, where A ∈ N and α ∈ (N ∪ T )∗ . A language L is a context-free language if there is a context-free grammar G such that L = L(G). Let CF be the class of context-free languages. A context-free grammar G = (N, T, P, S) is in Chomsky normal form if each production rule in P is of one of the following forms:

650

K. Onodera

1. X → Y Z, where X, Y, Z ∈ N . 2. X → a, where X ∈ N , a ∈ T . 3. S → λ (only if S does not appear in right-hand sides of production rules). It is well known that, for each context-free language L, there is a context-free grammar in Chomsky normal form generating L [8]. A grammar G = (N, T, P, S) is regular if P is a finite set of rules of the form X → α, where X ∈ N and α ∈ T N ∪ T ∪ {λ}. A language L is a regular language if there is a regular grammar G such that L = L(G). Let REG be the class of regular languages. We are going to define a strictly locally testable language, which is one of the main objectives of the present work. Let k be a positive integer. A language L over T is strictly k-testable if there is a triplet Sk = (A, B, C) with A, B, C ⊆ T k such that, for any w with |w| ≥ k, w is in L iff P rek (w) ∈ A, Sufk (w) ∈ B, Intk (w) ⊆ C. Note that if L is strictly k-testable, then L is strictly k  -testable for all k  > k. Further, the definition of strictly k-testable says nothing about the strings of “length k − 1 or less”. A language L is strictly locally testable iff there exists an integer k ≥ 1 such that L is strictly k-testable. Let LOC(k) be the class of strictly k-testable languages. Then one can prove the following theorem. Theorem 1. [9] LOC(1) ⊂ LOC(2) ⊂ · · · ⊂ LOC(k) ⊂ · · · ⊂ REG. We are now going to define an insertion system. An insertion system (ins system, for short) is a triple γ = (T, P, AX ), where T is an alphabet, P is a finite set of insertion rules of the form (u, x, v) with u, x, v ∈ T ∗ , and AX is a finite set of strings over T called axioms. r We write α =⇒γ β if α = α1 uvα2 and β = α1 uxvα2 for some insertion rule r : (u, x, v) ∈ P with α1 , α2 ∈ T ∗ . If there is no confusion, we write α =⇒ β. The reflexive and transitive closure of =⇒ is defined by =⇒∗ . A language generated by γ is defined by L(γ) = {w ∈ T ∗ | s =⇒∗γ w, for some s ∈ AX }. An insertion system γ = (T, P, AX ) is said to be of weight (m, n) if m = max{ |x| | (u, x, v) ∈ P }, n = max{ |u| | (u, x, v) ∈ P or (v, x, u) ∈ P }. n denotes the class of all languages generated by ins For m, n ≥ 0, IN Sm  systems of weight (m , n ) with m ≤ m and n ≤ n. When the parameter is not bounded, we replace m or n with ∗. For insertion systems, there exist the following results.

Theorem 2. [2] 1. F IN ⊂ IN S∗0 ⊂ IN S∗1 · · · ⊂ IN S∗∗ ⊂ CS. 2. REG ⊂ IN S∗∗ .

New Morphic Characterizations of Languages in Chomsky Hierarchy

651

3. IN S∗1 ⊂ CF . 4. CF is incomparable with all IN S∗n (n ≥ 2), and IN S∗∗ . 5. IN S22 contains non-semilinear languages. From the definition of insertion systems, we can easily prove the following lemma. Lemma 1. IN S10 ⊂ REG. A mapping h : V ∗ → T ∗ is called morphism if h(λ) = λ and h(xy) = h(x)h(y) for any x, y ∈ V ∗ . For languages L1 , L2 , and morphism h, we use the following notation: h(L1 ∩ L2 ) = {h(w) | w ∈ L1 ∩ L2 }. For language classes L1 and L2 , we introduce the following class of languages: H(L1 ∩ L2 ) = {h(L1 ∩ L2 ) | h is a morphism, Li ∈ Li (i = 1, 2)}.

3

Characterizations of Regular Languages

In this section, we will characterize regular languages in terms of insertion languages and strictly locally testable languages both of which form proper subclasses of regular languages. Lemma 2. REG ⊆ H(IN S10 ∩ LOC(2)). Proof. For a regular language L, let G = (N, T, P, S) be a regular grammar such that L = L(G). Using the new symbol F , we construct the insertion system γ = (V, P  , {λ}) of weight (1, 0), where V = {Xr | r : X → α ∈ P } ∪ {F }, P  = {(λ, X, λ) | X ∈ V }. Then, L(γ) = V ∗ . Further, we define the morphism h : V ∗ → T ∗ by h(Xr ) = a h(Xr ) = λ h(F ) = λ.

if r : X → aY ∈ P or r : X → a ∈ P, if r : X → λ ∈ P,

Finally, consider R = AV ∗ ∩ V ∗ B − V + C  V + with C  = V 2 − C, where A = {Sr Xr1 | r : S → aX ∈ P, r1 : X → α ∈ P, α ∈ T ∪ T N ∪ {λ}}∪ {Sr F | r : S → α ∈ P, α ∈ T ∪ {λ}}, B = {Xr F | r : X → a ∈ P or r : X → λ ∈ P }, C = {Xr Yr1 | r : X → aY ∈ P, r1 : Y → α ∈ P, α ∈ T ∪ T N ∪ {λ}}. Then R is a strictly 2-testable language prescribed by S2 = (A, B, C). rn−1 r1 rn   ∗ We can prove that, for any X ∈ N , X =⇒ G · · · =⇒ G w Y =⇒G w y = w ∈ T ∗ ∗  + iff Xr1 · · · Yrn F ∈ V B − V C V with h(Xr1 · · · Yrn F ) = w by the induction on n. We omit the proof here. Considering the special case X = S, then a string w is in L(G) iff w is in h(L(γ) ∩ R). 

652

K. Onodera

Lemma 3. H(IN S10 ∩ LOC(2)) ⊆ REG. Proof. Since the class of regular languages is closed under intersection with regular languages and morphisms, the result follows from the facts that IN S10 ⊂ REG in Lemma 1 and LOC(2) ⊂ REG in Theorem 1. 

From Lemma 2 and Lemma 3, we have the following theorem. Theorem 3. REG = H(IN S10 ∩ LOC(2)). Since for arbitrary k with k ≥ 2, the class of regular languages includes the class of strictly k-testable languages, the next result follows from Theorem 3 and Theorem 1. Corollary 1. REG = H(IN S10 ∩ LOC(k)) ( k ≥ 2 ). The value of parameter k = 2 in the strictly k-testable languages in Theorem 3 is necessary for expressing regular languages in the following sense. Lemma 4. There exists a regular language which cannot be written in the form h(L(γ)∩R), for any insertion system γ of weight (i, 0) (∀i ≥ 1), strictly 1-testable language R, and morphism h. Proof. Consider the regular language L = {al | l ≥ 0} ∪ {bl | l ≥ 0}. Suppose that there is an insertion system γ = (V, P, AX ) of weight (i, 0) with i ≥ 1, a strictly 1-testable language R prescribed by S1 = (A, B, C), and a morphism h such that L = h(L(γ) ∩ R). Then, for any l ≥ 0, there exists the set of strings Dl = {x | h(x) = al } ∪ {y | h(y) = bl } such that Dl ⊂ L(γ) ∩ R. Let D = ∪ Dl , then D is an infinite set. l≥0

Since D ⊂ L(γ) ∩ R holds, L(γ) ∩ R is also an infinite set. Then P includes both (λ, ua , λ) and (λ, ub , λ), where ua , ub ∈ C i , h(ua ) = aia , h(ub ) = bib for some ia , ib > 0. Let t1 xt2 and t3 yt4 be in L(γ) ∩ R with t1 , t3 ∈ A, t2 , t4 ∈ B, ua ∈ Inti (t1 xt2 ), ub ∈ Inti (t3 yt4 ). Then, the string t1 ub xt2 is in L(γ) ∩ R satisfying |h(t1 ub xt2 )|a ≥ ia > 0 and |h(t1 ub xt2 )|b ≥ ib > 0, which contradicts to the fact that L = {al | l ≥ 0} ∪ {bl | l ≥ 0}. 

From Lemma 4, Theorem 1, and Theorem 3, we have the following theorem. Theorem 4. H(IN S10 ∩ LOC(1)) ⊂ REG. The value of weight (1, 0) in insertion systems in Theorem 3 is optimal for expressing regular languages in the following sense. Lemma 5. There exist an insertion system γ of weight (2, 0), a strictly 1testable language R, and a morphism h such that h(L(γ) ∩ R) is non-regular. Proof. Consider an insertion system γ = (T, {λ}, {(λ, ab, λ)}) with T = {a, b}. Then, for any w in L(γ), |w|a = |w|b holds.

New Morphic Characterizations of Languages in Chomsky Hierarchy

653

Consider R = AT ∗ ∩T ∗ B −T + C  T + with C  = T −C, where A = B = C = T . Then R = T + is a strictly 1-testable language prescribed by S1 = (T, T, T ). Further, we define a morphism h : T ∗ → T ∗ by h(c) = c for any c ∈ T . Then, we have L(γ) ∩ R = h(L(γ) ∩ R) = {w | w ∈ L(γ), w = λ}. For a regular language R∗ = {ai bj | i, j ≥ 1}, h(L(γ)∩R)∩R∗ = {ai bi | i ≥ 1}, which is not regular. From the fact that the class of regular languages is closed under intersection with regular languages, h(L(γ) ∩ R) is not regular. 

0 with i ≥ 1, we From Lemma 4, Lemma 5, and the fact that IN Si0 ⊆ IN Si+1 have the following corollary.

Corollary 2. REG and H(IN Si0 ∩ LOC(1)) are incomparable ( i ≥ 2 ). From Lemma 5, Theorem 2, and Theorem 1, we have the following corollary. Corollary 3. REG ⊂ H(IN Si0 ∩ LOC(k)) ( i ≥ 2, k ≥ 2 ).

4

Characterizations of Context-Free Languages

We will show how context-free languages can be characterized by insertion systems and strictly locally testable languages. In some respect the proof technique from [7] might be helpful to follow the main proof of this section. Lemma 6. CF ⊆ H(IN S30 ∩ LOC(4)). Proof. Consider a context-free grammar G = (N, T, P, S) in Chomsky normal form. We construct an insertion system γ = (Σ, Pγ , {S}), where Σ = V ∪ V¯ ∪ T V = N ∪ Lab(P ), ¯ r¯, λ) | r : X → Y Z ∈ P }∪ Pγ = {(λ, Y Zr, λ), (λ, X ¯ r¯, λ) | r : X → a ∈ P }∪ {(λ, ar, λ), (λ, X {(λ, r, λ), (λ, S¯r¯, λ) | r : S → λ ∈ P }. For the rule r : X → α in P , we say that the two insertion rules (λ, αr, λ) and ¯ r¯, λ) in Pγ are r-pair. (λ, X We define the projection h : Σ ∗ → T ∗ by h(a) = a h(a) = λ

for all a ∈ T, otherwise.

Consider R = AΣ ∗ ∩ Σ ∗ B − Σ + C  Σ + with C  = Σ 4 − C, where ¯ | r : X → a ∈ P } ∪ {rS S¯r¯ | r : S → λ ∈ P }, A = {arX X B = {rS S¯r¯ | r : S → α ∈ P, α ∈ (N ∪ T )∗ }, ¯ r¯, X X ¯ r¯a, X X ¯ r¯r1 , X ¯ r¯ar1 , X ¯ r¯r1 Y, r¯1 arX, r¯1 rX X, ¯ arX X ¯ | C = {rX X r : X → α ∈ P, r1 : Y → α1 ∈ P, a ∈ T, α, α1 ∈ (N ∪ T )∗ }.

654

K. Onodera

Then R is a strictly 4-testable language prescribed by S4 = (A, B, C). The language R can be characterized by using ¯ r¯ | r : X → α ∈ P, α ∈ (N ∪ T )∗ } Ω = {rX X ¯ r¯ ∈ Ω such that R ⊂ (Ω ∪ T Ω)∗ (B ∪ T B). A nonterminal symbol X in rX X is said to be Ω-blocked. A symbol in N ∪ T which is not Ω-blocked is said to ¯ r¯ means be unblocked. Intuitively, an Ω-blocked nonterminal symbol X in rX X that X has been used for the rule r. Further, based on γ and R, we define the followings: for each X ∈ N , let γX = (Σ, Pγ , {X}) be an insertion grammar, and let RX = AΣ ∗ ∩ Σ ∗ BX − Σ + C  Σ ∗ ¯ r¯ | r : X → α ∈ P, α ∈ be a strictly 4-testable language, where BX = {rX X ∗ +  ∗ (N ∪ T ) }. There is a slight note on the form of Σ C Σ in RX . Then RX can be characterized by RX ⊂ (Ω ∪ T Ω)∗ . For the case X = S, γS = γ and BS = B hold. r1 ···rn We can prove that, for any X in N , if there is a derivation X =⇒ G a1 · · · al with ai ∈ T (1 ≤ i ≤ l) then there is a string – w = a1 u1 · · · al ul in L(γX ) ∩ RX , ¯ r¯1 }, where l ≥ 2, ui ∈ Ω + (1 ≤ i ≤ l − 1), and ul ∈ Ω ∗ {r1 X X – w = a1 u1 in L(γX ) ∩ RX , ¯ r¯1 } where u1 ∈ Ω ∗ {r1 X X

or

by induction on the length n of derivations in G. We omit the proof here. Conversely, we will show that, for nonempty string w in L(γ) ∩ R, h(w) is in L(G). We start by showing that if a string w is in L(γX ) ∩ RX , then there is a derivation X =⇒∗G h(w). Suppose that w is in L(γX ) ∩ RX . In order to derive the string w in RX ⊂ (Ω ∪ T Ω)∗ , without loss of generality, we may assume here that, for each r in P , the first two steps in γX are performed by r-pair insertion rules. For the derivation X =⇒2n γX w, we can prove the claim by induction on n. We omit the proof here. For the case X = S, if there is a nonempty string w ∈ L(γ) ∩ R, then a string h(w) is in L(G). Finally let us consider the case that λ is in L(G). Since G is in Chomsky r normal form, λ is in L(G) if and only if for λ there is a derivation S =⇒ λ. By the construction of Pγ and R, the string λ is in L(G) if and only if (λ, r, λ), (λ, S¯r¯, λ) ∈ Pγ and rS S¯r¯ ∈ A ∩ B. Then there is a derivation S =⇒γ ¯r =⇒γ rS S¯r¯ ∈ A ∩ B. From the definition of h, h(rS S¯r¯) = λ. Therefore, λ is S S¯ in L(G) if and only if λ is in h(L(γ) ∩ R). 

It is known that the class of context-free languages includes the class of insertion languages of weight (3, 0) [10]. Together with the fact that the class of context-free languages is closed under intersection with regular languages and morphisms, we have the following lemma.

New Morphic Characterizations of Languages in Chomsky Hierarchy

655

Lemma 7. H(IN S30 ∩ LOC(4)) ⊆ CF . From Lemma 6 and Lemma 7, we have the following theorem. Theorem 5. CF = H(IN S30 ∩ LOC(4)). Furthermore, from the fact that for arbitrary k with k ≥ 1, the class of regular languages includes the class of strictly k-testable languages, we have the following corollary. Corollary 4. CF = H(IN S30 ∩ LOC(k)) ( k ≥ 4 ).

5

Characterizations of RE Languages

In this section, we will show that any recursively enumerable language can be represented by using insertion systems and strictly locally testable languages in the similar way to context-free and regular languages. Theorem 6. RE = H(IN S33 ∩ LOC(2)). Construction of an insertion system γ: Let G = (N, T, P, S) be a type-0 grammar in Penttonen normal form. In this normal form, the rules in P are of the following types: Type 1 : X → α ∈ P, where X ∈ N, α ∈ (N ∪ T )∗ , |α| ≤ 2. Type 2 : XY → XZ ∈ P, where X, Y, Z ∈ N. By introducing new symbols # and c, we construct the insertion system γ = (Σ, Pγ , {Scc}), where Σ = N ∪T ∪{#, c} and Pγ contains the following insertion rules: – Group 1: For each rule r : X → Y Z ∈ P of Type 1, with X ∈ N and Y, Z ∈ N ∪ T ∪ {λ}, we construct the following insertion rules form-(r1 ) (X, #Y Z, α1 α2 ) in Pγ , where α1 α2 ∈ (N ∪ T ∪ {c})2 . – Group 2: For each rule r : XY → XZ ∈ P of Type 2, with X, Y, Z ∈ N , we construct the following insertion rules form-(r2 )

(XY, #Z, α1 α2 ) in Pγ , where α1 α2 ∈ (N ∪ T ∪ {c})2 .

– Group 3 (Relocation task for X): For each X, Y ∈ N , we construct the following insertion rules form-(r3 ) form-(r4 ) form-(r5 )

(XY #, #X, α), where α ∈ (N ∪ T ∪ {c}), (X, #, Y ##), (#Y #, Y, #X).

656

K. Onodera

We define a projection h : Σ ∗ → T ∗ by h(a) = a h(a) = λ

for all a ∈ T, otherwise.

Finally, let R = AΣ ∗ ∩ Σ ∗ B − Σ + C  Σ + with C  = Σ 2 − C, A = {X# | X ∈ N }, B = {cc}, C = {X# | X ∈ N } ∪ {#X | X ∈ N } ∪ {aX | X ∈ N }∪ {ab | a, b ∈ T } ∪ {ac | a ∈ T } ∪ {#a | a ∈ T } ∪ {#c}. Then R is a strictly 2-testable language prescribed by S2 = (A, B, C). The language R can be represented by R = N {#}(T ∪ N {#})∗ {cc}. Then we obtain L(G) = h(L(γ) ∩ R), which will be proven in the sequel. We start by introducing some useful notions. We call the symbol # a marker. A symbol in N followed by # is said to be #-marked (briefly marked ). A symbol in N ∪ T which is not marked is said to be unmarked. We call a string in N {#} a wreck and a string in (N {#})+ a wrecks. Since the symbols c and # are special symbols, they are neither marked nor unmarked. A string xcc, where x is in (N {#} ∪ N ∪ T )∗ , is a legal string. An intuitive explanation of marked symbols and unmarked symbols is the followings: Note 1. A marked symbol means that the symbol has been used (i.e. consumed) for some derivation in γ. Note 2. In γ at each step a string consisting of unmarked symbols of a legal string indicates a sentential form of G. By the construction of R, making L(γ) ∩ R leads to only legal strings. Then if we erase the “wrecks” and the symbol c, we get the legal strings of unmarked symbols which are exactly sentential forms of G. By using the rules of Group 1 and Group 2, we can simulate the rules of Type 1 and Type 2 respectively. By using the rules of Group 3, we move an unmarked symbol to the right across a block M #, where M ∈ N . Thus the nonterminal pairs XY can be ready for simulating the rules XY → Y Z of Type 2. In order to prove the equality L(G) = h(L(γ)∩R), we first prove the inclusion L(G) ⊆ h(L(γ) ∩ R). Fact 1. Applying a form-(r1 ) rule : (X, #Y Z, α1 α2 ) to an occurrence of a string Xα1 α2 with α1 α2 ∈ (N ∪ T ∪ {c})2 makes a new occurrence of the string X#Y Zα1 α2 . Note that the unmarked symbol X becomes marked, while the symbols Y, Z are newly created unmarked symbols. Fact 2. Applying a form-(r2 ) rule : (XY, #Z, α1 α2 ) to an occurrence of a string XY α1 α2 with α1 α2 ∈ (N ∪ T ∪ {c})2 makes a new occurrence of the string XY #Zα1 α2 . Note that the symbol X is preserved in just the unmarked state, the unmarked symbol Y becomes marked, while the symbol Z is newly created unmarked symbol.

New Morphic Characterizations of Languages in Chomsky Hierarchy

657

Lemma 8. The rules in Group 3 can replace a substring XY #α (α ∈ N ∪ T ∪ {c}) by a substring consisting of the strings in N {#} and ending with Xα. The symbol X is unmarked before and after the derivations. Proof. A form-(r3 ) rule (XY #, #X, α) can be applied to a string XY #α, where X, Y ∈ N , α ∈ N ∪ T ∪ {c}. After applying the form-(r3 ) rule, we have XY ##Xα. Then the form-(r4 ) rule (X, #, Y ##) can be applied for the substring XY ##, and we have X#Y ##Xα. Now we apply the form-(r5 ) rule (#Y #, Y, #X) for the substring #Y ##X, and the substring is replaced by #Y #Y #X. Therefore, the substring XY #α is replaced by X#Y #Y #Xα, which has the unmarked symbol X on the rightmost position. 

Thus the insertion rules in γ simulate the rules in G, and generate legal strings from the legal string Scc. We will give separate consideration to the case of using the rules in Group 3. Lemma 9. Once the form-(r3 ) rule : (XY #, #X, α) is applied to obtain a substring of a legal string, then the form-(r4 ) rule and form-(r5 ) rule are used in this order. Proof. We may consider a substring XY #α, where X, Y ∈ N , α ∈ N ∪ T ∪ {c}. After using rule in form-(r3 ), we obtain XY ##Xα. Because of the symbols ##, rules in form-(r1 ) or (r2 ) or (r3 ) cannot be applied for the substring XY ##. In view of the construction of form-(r5 ) rule, we cannot apply a form-(r5 ) rule for XY ##. Hence, the only applicable rule for XY ## is form-(r4 ) rule. After using form-(r4 ) rule (X, #, Y ##) for XY ##Xα, we obtain the substring X#Y ##Xα. For the symbol X following ##, we have a chance to apply one of the rules in form-(r1 ), (r2 ), (r3 ), (r4 ). If we apply form-(r1 ) or form-(r2 ) rule, we may take it as the first step of simulation for Type 1 or Type 2 respectively. Note that, during these simulations, X remains at the immediately to the right of ##. If we apply form-(r3 ) or form-(r4 ) rule, we may take it independently a new relocation task. Note that, after application of form-(r3 ) or form-(r4 ) rule, X remains immediately to the right of ##. Therefore, in all cases the symbol ## is followed by X. Further, since the symbol X was originally unmarked in XY #α, X provides the possibility of applying one of the rules in form-(r1 ), (r2 ), (r3 ), (r4 ). Hence this application causes no trouble with the current relocation task. After using form-(r4 ) rule for XY ##, we obtain X#Y ##. From the above notation, since X always follows the symbols ##, after applying form-(r4 ) rule, we obtain X#Y ##X. In the substring X#Y ##, both of the symbols X and Y are already marked, and in view of the form of the rules, none of form-(r1 ), (r2 ), (r3 ), (r4 ) rule can be used for this substring. Hence, the only applicable rule for X#Y ##X is form-(r5 ) rule. After applying this rule, (#Y #, Y, #X), we have X#Y #X#X, which is the substring of a legal string. Hence to obtain a substring of a legal string, whenever we use the form-(r3 ) rule, we have to use form-(r4 ) rule and (r5 ) rule in this order. 

658

K. Onodera π

From Lemma 9, for any derivation in γ, x =⇒γ y, there is a standard derivation which satisfies that form-(r4 ) rule and form-(r5 ) rule are applied in this order immediately after applying form-(R3 ) rule. Denote by umk(x) a string consisting of unmarked symbols in a legal string x generated by γ. Note that since c is the special symbol, neither marked nor unmarked, umk(x) does not contain a suffix cc. We thus have the next lemma. Lemma 10. The nonterminal symbol S derives x in G if and only if there is a derivation Scc =⇒∗γ x in γ such that umk(x ) = x. Proof. We will show that if there is a derivation S =⇒nG x then there is a derivation Scc =⇒∗γ x such that umk(x ) = x by induction on n. Base step: If n = 0, then for the axiom Scc in γ, umk(Scc) = S holds. Thus obviously the claim holds. Induction step: We suppose that the claim holds for any k ≤ n. Now consider a derivation S =⇒nG x =⇒G y. From the induction hypothesis, there is a derivation Scc =⇒∗γ x , where umk(x ) = x. If the rule applied for x is of Type 1 (Type 2, resp.) then we use the corresponding insertion rule in Group 1 (Group 2, resp.) for the string x . However, in the latter case (i.e. Group 2), if the insertion rule in Group 2 cannot be immediately applied for x , we need to apply some rules in Group 3. From Lemma 8, after application of the rules in Group 3, unmarked symbols of a legal string x remain unchanged. We denote this process of derivations by x =⇒∗γ x =⇒γ y  , where x , which is a string ready for applying a rule in Group 2, is derived by using only rules in form-(r3 ), (r4 ), (r5 ) in Group 3 and y  is derived by using only a rule in Group 2. Note that umk(x ) = umk(x ). Then, in either case, from Fact 1 and Fact 2 we eventually have umk(y  ) = y. Therefore the claim holds for n + 1. π Conversely, we can prove that if there is a standard derivation Scc =⇒γ x then there is a derivation S =⇒∗G x such that umk(x ) = x by induction on the number n of legal strings in the derivation π. We omit the proof here. 

In view of the manner of constructing the strictly 2-testable language R and the projection h, we have the following fact. Fact 3. For any y ∈ L(γ), if y is in R and umk(y) ∈ T ∗ , then umk(y) = h(y). From Lemma 10 and Fact 3, we obtain the inclusion L(G) ⊆ h(L(γ) ∩ R). Next we prove the inverse inclusion which completes the proof of Theorem 6. Fact 4. As far as unmarked symbols are concerned, the rules in Group 1 and Group 2 can only simulate the rules of Type 1 and Type 2 respectively in G. Proof of Theorem 6. From Fact 4, Lemma 9 and Lemma 10, every string of a form umk(xcc) is generated by the grammar G, where xcc is a legal string generated by γ. Therefore, if for any y ∈ L(γ), y is in R, then there is a string h(y) such that S =⇒∗G h(y). This means that the inclusion h(L(γ) ∩ R) ⊆ L(G) holds. Together with the fact that L(G) ⊆ h(L(γ) ∩ R), we complete the proof of Theorem 1. 

New Morphic Characterizations of Languages in Chomsky Hierarchy

6

659

Conclusion

In this paper, we have contributed to the study of insertion systems with new characterizations of recursively enumerable, context-free, and regular languages. Specifically, we have shown that REG = H(IN S10 ∩ LOC(k)) with k ≥ 2. H(IN S10 ∩ LOC(1)) ⊂ REG ⊂ H(IN Si0 ∩ LOC(k)) with i, k ≥ 2. CF = H(IN S30 ∩ LOC(k)) with k ≥ 4. RE = H(IN S33 ∩ LOC(k)) with k ≥ 2. The followings are open problems: Can CF be represented as CF = H(IN S30 ∩ LOC(k)) for some k < 4 ? Can RE be represented as RE = H(IN Sij ∩ LOC(2)) for some i < 3 or j < 3 ?

Acknowledgements The author is deeply indebted to T.Yokomori for his helpful discussions. This work is supported in part by Grant-in-Aid for the Research Institute for Science and Technology of Tokyo Denki University with no.Q07J-05.

References 1. Margenstern, M., P˘ aun, G., Rogozhin, Y., Verlan, S.: Context-free insertiondeletion systems. Theor. Comput. Sci. 330(2), 339–348 (2005) 2. P˘ aun, G., Rozenberg, G., Salomaa, A.: DNA Computing. New Computing Paradigms. Springer, Heidelberg (1998) 3. Yokomori, T., Kobayashi, S.: Learning local languages and their application to DNA sequence analysis. IEEE Trans. Pattern Anal. Mach. Intell. 20(10), 1067– 1079 (1998) 4. Head, T.: Splicing representations of strictly locally testable languages. Discrete Applied Math. 87, 87–139 (1998) 5. Martin-Vide, C., P˘ aun, G., Salomaa, A.: Characterizations of recursively enumerable languages by means of insertion grammars. Theor. Comput. Sci. 205(1-2), 195–205 (1998) 6. Onodera, K.: A note on homomorphic representation of recursively enumerable languages with insertion grammars. IPSJ Journal 44(5), 1424–1427 (2003) 7. P˘ aun, G., P´erez-Jim´enez, M.J., Yokomori, T.: Representations and characterizations of languages in Chomsky hierarchy by means of insertion-deletion systems. Int. J. Found. Comput. Sci. 19(4), 859–871 (2008) 8. Rozenberg, G., Salomaa, A. (eds.): Handbook of formal languages. Springer, New York (1997) 9. McNaughton, R., Papert, S.A.: Counter-Free Automata. M.I.T. research monograph, vol. 65. MIT Press, Cambridge (1971) 10. Verlan, S.: On minimal context-free insertion-deletion systems. J. Autom. Lang. Comb. 12(1), 317–328 (2007)

On Parallel Communicating Grammar Systems and Correctness Preserving Restarting Automata Dana Pardubská1, , Martin Plátek2, , and Friedrich Otto3 1

3

Dept. of Computer Science, Comenius University, Bratislava [email protected] 2 Dept. of Computer Science, Charles University, Prague [email protected] Fachbereich Elektrotechnik/Informatik, Universität Kassel, Kassel [email protected]

Abstract. This paper contributes to the study of Freely Rewriting Restarting Automata (FRR-automata) and Parallel Communicating Grammar Systems (PCGS) as formalizations of the linguistic method of analysis by reduction. For PCGS we study two complexity measures called generation complexity and distribution complexity, and we prove that a PCGS Π, for which both these complexity measures are bounded by constants, can be simulated by a freely rewriting restarting automaton of a very restricted form. From this characterization it follows that the language L(Π) is semilinear, that its characteristic analysis is of polynomial size, and that this analysis can be computed in polynomial time.

1

Introduction

This paper contributes to the analysis of Freely Rewriting Restarting Automata (FRR-automata) and Parallel Communicating Grammar Systems (PCGS), see [1,2]. Here the main goal is the quest for constraints for FRRs and PCGSs, under which the corresponding classes of languages and their analysis by reduction are of interest from the point of view of computational linguistics. For example, this is the case if the languages obtained are semi-linear, and if their so-called characteristic analysis can be computed in polynomial time. Freely rewriting restarting automata create a suitable tool for modelling the so-called analysis by reduction. In general, analysis by reduction explains basic types of so-called dependencies in sentences of natural languages. The Functional Generative Description for the Czech language developed in Prague (see, e.g., [3]) is based on this method. In order to model analysis by reduction, FRR-automata work on so-called characteristic languages, that is, on languages with auxiliary symbols (categories) included in addition to the input symbols. The proper language is obtained from  

Partially supported by the Slovak Grant Agency for Science (VEGA) under contract “1/0726/09 - Algorithmic and complexity issues in information processing”. Partially supported by the Grant Agency of the Czech Republic under Grant No. 405/08/0681 and by the program Information Society under project 1ET100300517.

A.H. Dediu, A.M. Ionescu, and C. Martín-Vide (Eds.): LATA 2009, LNCS 5457, pp. 660–671, 2009. c Springer-Verlag Berlin Heidelberg 2009 

On PCGS and Correctness Preserving Restarting Automata

661

a characteristic language by removing all auxiliary symbols from its sentences. We focus on restarting automata that ensure the correctness preserving property for the analysis, that is, after any restart within a computation starting with a word from the characteristic language, the content of the tape is again from that language. This property is required in order to introduce the notion of characteristic analysis in a linguistically adequate way. To achieve our goal we use a technique that is based on the notion of skeletal set, which is particularly useful for error recovery during a robust parsing or during a grammar-checking procedure. We study two complexity measures for returning PCGSs with regular components: the generation complexity 1 , which bounds the number of generative sections in a word generated by a PCGS, and the distribution complexity 2 , which bounds the distribution of concurrently generated segments over the word generated. Our technical main result states the following. If Π is a PCGS, for which the generation complexity is bounded by a constant g and the distribution complexity is bounded by a constant d, then the language L(Π) generated by Π is the proper language of a freely rewriting restarting automaton M of a very restricted form: M is correctness preserving, and it only performs rewrite operations of a very restricted type. In addition, the number of rewrites per cycle and the number of auxiliary symbols that occur in any word from the characteristic language of M are both bounded by constants that depend on the bounds g and d above. In fact, M even has a skeletal set of type (g, d). Based on these restrictions of M we obtain the following important results on the language L(Π): it is semi-linear, its characteristic analysis is of polynomial size, and it can be computed in polynomial time, where the degree of the polynomial time-bound also depends on the constants g and d. The latter two results answer questions that were left open in [1,2]. The structure of the paper is as follows. In Section 2 we give the (informal) definitions of FRR-automata, AuxRR-automata, and PCGS and present some basic facts about them. In Section 3, which constitutes the technical main part of the paper, we present our simulation result described above, and we then introduce the notion of skeletal set. Using this notion we derive the main results of the paper from the simulation given in the first part of this section. This section ends with some concluding remarks.

2

Basic Notions

Restarting automata. A freely rewriting restarting automaton (FRR-automaton, for short) is a restarting automaton without rewriting constraints, that is, it is a nondeterministic machine with a flexible tape, a read/write window of a fixed size k ≥ 1 that can move along this tape, and a finite-state control. Formally, it is described by an 8-tuple M = (Q, Σ, Γ, c, $, q0 , k, δ). Here Q denotes a finite set of (internal) states that contains the initial state q0 , Σ is a finite input alphabet, 1 2

The generation complexity corresponds to the degree of (linguistic) independence. The distribution complexity models the degree of (linguistic) dependence (valence).

662

D. Pardubská, M. Plátek, and F. Otto

and Γ is a finite tape alphabet that contains Σ. The elements of Γ  Σ are called auxiliary symbols. The additional symbols c, $ ∈ Γ are used as markers for the left and right end of the workspace, respectively. They cannot be removed from the tape. The behavior of M is described by a transition function δ that associates a finite set of transition steps to each pair of the form (q, u), where q is a state and u is a possible content of the read/write window. There are four types of transition steps: move-right steps, rewrite steps, restart steps, and accept steps. A move-right step simply shifts the read/write window one position to the right and changes the internal state. A rewrite step causes M to replace a nonempty prefix u of the content of the read/write window by a word v satisfying |v| ≤ |u|, and to change the state. Further, the read/write window is placed immediately to the right of the string v. A restart step causes M to place its read/write window over the left end of the tape, so that the first symbol it sees is the left sentinel c, and to reenter the initial state q0 . Finally, an accept step simply causes M to halt and accept. A configuration of M is described by a string αqβ, where q ∈ Q, and either α = ε (the empty word) and β ∈ {c} · Γ ∗ · {$} or α ∈ {c} · Γ ∗ and β ∈ Γ ∗ · {$}; here q represents the current state, αβ is the current content of the tape, and it is understood that the window contains the first k symbols of β or all of β when |β| ≤ k. A restarting configuration is of the form q0 cw$, where w ∈ Γ ∗ . Any computation of M consists of certain phases. A phase, called a cycle, starts in a restarting configuration. The window is shifted along the tape by move-right and rewrite operations until a restart operation is performed and thus a new restarting configuration is reached. If no further restart operation is performed, the computation necessarily finishes in a halting configuration – such a phase is called a tail. It is required that in each cycle, M performs at least one rewrite step that is strictly length-decreasing. Thus, each cycle strictly reduces the length of the tape. We use the notation u cM v to denote a cycle of M that begins with the restarting configuration q0 cu$ and ends with the restarting ∗ configuration q0 cv$; the relation cM is the reflexive and transitive closure of cM . ∗ A word w ∈ Γ is accepted by M , if there is a computation which starts from the restarting configuration q0 cw$, and ends with an application of an accept step. By LC (M ) we denote the so-called characteristic language of M , which is the language consisting of all words accepted by M . By PrΣ we denote the projection from Γ ∗ onto Σ ∗ , that is, PrΣ is the morphism defined by a → a (a ∈ Σ) and A → ε (A ∈ Γ  Σ). If v := PrΣ (w), then v is the Σ-projection of w, and w is an expanded version of v. For a language L ⊆ Γ ∗ , PrΣ (L) := { PrΣ (w) | w ∈ L }. Further, for K ⊆ Γ , |x|K denotes the number of occurrences of symbols from K in x. Motivated by linguistic considerations to model the analysis by reduction with parallel processing, we are interested in the so-called proper language of M , which is the set of words LP (M ) := PrΣ (LC (M )). Hence, a word v ∈ Σ ∗ belongs to LP (M ) if and only if there exists an expanded version u of v such that u ∈ LC (M ). Realize that the main difference between the input and the

On PCGS and Correctness Preserving Restarting Automata

663

proper language lies in the way in which auxiliary symbols are inserted into the (terminal) words of the language. An FRR-automaton M is called linearized if there exists a constant j such that |w|Γ Σ ≤ j · |w|Σ + j for each w ∈ LC (M ) [1,2]. Since a linearized FRRautomaton only uses linear space, we see immediately that the proper language of each linearized FRR-automaton is context-sensitive. In a real process of analysis by reduction of a sentence of a natural language it is desired that whatever is done within the process does not change the correctness of the sentence. For restarting automata this property can be formalized as follows: An FRR-automaton M is correctness preserving if u ∈ LC (M ) and ∗ u cM v imply that v ∈ LC (M ), too. While it is easily seen that each deterministic FRR-automaton is correctness preserving, there are FRR-automata which are not correctness preserving. Let M = (Q, Σ, Γ, c, $, q0 , k, δ) be an FRR-automaton that is correctness preserving, and let w ∈ Σ ∗ . Then AC (w, M ) = { wC ∈ LC (M ) | wC is an extended version of w } is called the characteristic analysis of w by M . Definition 1. An FRR-automaton M = (Q, Σ, Γ, c, $, q0 , k, δ) is called aux-rewriting if, for each of its rewrite operations (q  , v) ∈ δ(q, u), PrΣ (v) is obtained from PrΣ (u) by deleting some symbols, and PrΓ \Σ (v) is obtained from PrΓ \Σ (u) by replacing some symbol by another symbol. By AuxRR we denote the class of aux-rewriting FRR-automata that are correctness preserving. For each type X of restarting automata and each t ∈ N+ , we use t -X to denote the class of X-automata that execute at most t rewrite steps in any cycle. Parallel Communicating Grammar Systems. A returning PCGS of degree m (≥ 1) with regular components is an (m + 1)-tuple Π = (G1 , . . . , Gm , K), where, for all i ∈ {1, . . . , m}, Gi = (Ni , T, Si , Pi ) are regular grammars, called  m component grammars, satisfying Ni ∩ T = ∅, and K ⊆ {Q1 , . . . , Qm } i=1 Ni is a set of special symbols, called communication symbols. A configuration of Π is an m-tuple C = (x1 , . . . , xm ), where xi = αi Ai , αi ∈ T ∗ , and Ai ∈ (Ni ∪ {ε}); we call xi the i-th component of the configuration. The nonterminal cut of configuration C is the m-tuple N (C) = (A1 , A2 , . . . , Am ). If N (C) contains at least one communication symbol, it is called an NC-cut and denoted by N C(C). A derivation of Π is a sequence of configurations D = C1 , C2 , . . . , Ct , where Ci+1 is obtained from Ci by one generative step or one communication step. If no communication symbol appears in any of the components, then we perform a generative step. It consists of synchronously performing a rewrite step in each of the component grammars Gi , 1 ≤ i ≤ m. If any of the components is a terminal string, it is left unchanged, and if any of the components contains a nonterminal that cannot be rewritten, the derivation is blocked. If the first component is a terminal word w, then w is the word that is generated by Π in this derivation. In this situation D is usually denoted as D(w). If a communication symbol is present in any of the components, then a communication step is performed. It

664

D. Pardubská, M. Plátek, and F. Otto

consists of replacing those communication symbols with the phrases they refer to for which the phrases themselves do not contain communication symbols. Such an individual replacement is called a communication. Obviously, in one communication step at most m − 1 communications can be performed. Communication steps are performed until no more communication symbols are present, or until the derivation is blocked because no communication symbol can be replaced. The maximal sub-sequence of communication steps forms a communication section. A generative section is a non-empty sequence of generative steps between two consecutive communication sequences in D (or before the first or after the last communication step). Thus, the communication steps divide the derivation into generative and communication sections. The (terminal) language L(Π) generated by Π is the set of terminal words that appear in the component G1 , which is called the master of the system: L(Π) = { α ∈ T ∗ | (S1 , . . . , Sm ) ⇒+ (α, β2 , . . . , βm ) }. Several notions are associated with the derivation D(w): • g(i, j) (or g(i, j, D(w))) denotes the (i, j)-(generative) factor of D(w), which is the terminal word that is generated by Gi within the j-th generative section of D(w); • n(i, j) (or n(i, j, D(w))) denotes the number of occurrences of g(i, j) in w. • The communication structure CS(D(w)) of D(w) captures the connection between the terminal word w and its particular derivation D(w)): CS(D(w)) = (i1 , j1 ), (i2 , j2 ), . . . , (ir , jr ), if w = g(i1 , j1 )g(i2 , j2 ) . . . g(ir , jr ).  • For j ≥ 1 let N (j, D(w)) = m i=1 n(i, j, D(w)). Then the so-called degree of distribution DD(D(w)) of D(w) is the maximum over all N (j, D(w)). • The trace of a (sub-)derivation D is the sequence T (D) of nonterminal cuts of individual configurations of D: T (D)=N (C0 ), N (C1 ), . . . , N (Ct ). Note that (in general) the trace does not unambiguously identify the derivation. • The communication sequence, resp. the NC-sequence, is defined analogously: N CS(D) is the sequence of all NC-cuts in the (sub-)derivation D. Realize that the communication sequence N CS(D(w)) unambiguously defines the communication structure of D(w). Moreover, the set of words with the same communication sequence/structure might, in general, be infinite. A cycle in a derivation D is a smallest (continuous) sub-derivation C = C1 , . . . , Cj of D such that N (C1 ) = N (Cj ). If none of the nonterminal cuts in C contains a communication symbol, then the whole cycle is contained in a generative section; we speak about a generative cycle in this case. If the first nonterminal cut contains communication symbols, which means that N (C1 ) = N (Cj ) are NC-cuts, then the cycle is called a communication cycle. If there is a cycle in the derivation D(w), then manifold repetition3 of the cycle is possible and the resulting derivation is again a derivation of some terminal word. Observe, however, that the repetition or deletion of a generative cycle does 3

Deletion of a cycle is also possible.

On PCGS and Correctness Preserving Restarting Automata

665

not change the communication structure of a derivation. We call a derivation D(w) reduced, if every repetition of any of its cycles leads to a longer terminal word ω; |w| < |ω|. Obviously, to every derivation D(w) there is an equivalent reduced derivation D (w) of the same word. In what follows, we consider only derivations that are reduced. Finally, we define several complexity measures for PCGS. Informally, the communication complexity of a derivation D (denoted com(D)) is defined as the number of communications performed within the derivation D; analogously, the distribution complexity of a derivation D is the degree of distribution defined above, and the generation complexity of the derivation D is the number of generative sections in D. Then the communication/distribution/generation complexity of a language and the associated complexity class are defined in the usual way (always considering the corresponding maximum). Here, we are mainly interested in those classes of languages for which all the complexity measures considered above are bounded from above by a constant. For natural numbers k, d, g, we denote the corresponding communication complexity class by COM(k), and the distribution and/or generation complexity class by d-DG, g-DD, and d-g-DDG, respectively. Some relevant observations characterizing the derivations of a PCGS with constant communication complexity are summarized in the following facts. Fact 1. Let Π be a PCGS with constant communication complexity. Then there are constants d(Π), (Π), s(Π), and e(Π) such that 1. the number n(i, j) of occurrences of individual g(i, j)’s in a reduced derivation is bounded by d(Π); that is, n(i, j) ≤ d(Π); 2. the length of the communication structure for every (reduced) derivation is bounded by (Π); 3. the cardinality of the set of all possible communication structures corresponding to a reduced derivation by Π is bounded by s(Π). 4. Let D(w) be a reduced derivation of a terminal word w in Π. If more than e(Π) generative steps are performed in the j-th generative section of D(w), then at least one factor g(i, j, D(w)) has been changed. Based on pumping arguments the following observation now follows easily. Proposition 1. Let Π be a PCGS with constant communication complexity. Then the set of all derivations by Π without a generative cycle is finite.

3

Analysis by Reduction for PCGSs

In [1] it is shown how to transform a PCGS with constant communication complexity into a deterministic linearized FRR-automaton. In what follows we will reduce the number of occurrences of auxiliary symbols in the words from the characteristic language of the corresponding restarting automaton to a constant by utilizing nondeterminism. In fact, the resulting automaton will be an AuxRRautomaton for which the positions at which rewrites are performed within a

666

D. Pardubská, M. Plátek, and F. Otto

cycle are severely restricted. These restrictions will be formalized through the notion of a skeletal set in Definition 2. Theorem 1. For each L ∈ g-d-DDG, there is a d-AuxRR-automaton M such that L = LP (M ). Moreover, the number of auxiliary symbols in w ∈ LC (M ) is bounded from above by the constant 2 · g · d + 2. Proof. Let L ∈ g-d-DDG, and let Π be a PCGS with m components that generates L with distribution complexity d and generation complexity g. Our construction is based on the fact that Π has only a finite number σ of cycle-free ˆ 1 (wˆ1 ), · · · , D ˆ σ (wˆσ )} be the set of these derivations. derivations. Let Cf = {D We describe a d-AuxRR-automaton M that, given a certain extended version wC of a word w, performs the analysis by reduction which starts by considering a Π-derivation D(w) of the word w ∈ L, and ends by checking that the Πˆ k (wˆk ) obtained is one of the cycle-free derivations listed above. derivation D Let w ∈ L, let D(w) be a derivation of w in Π, and let g(i, j) be the terminal word generated by the component grammar Gi within the j-th generative section. Then w can be written as w = g(i1 , j1 )g(i2 , j2 ) . . . g(ir , jr ). As Π has generation complexity g, there are at most g generative sections in the derivation D(w), and as Π has distribution complexity d, there are at most d occurrences of factors g(it , jt ) such that jt = j for any j. Hence, we have r ≤ d·g. To reconstruct the derivation of a factor g(i, j) in detail we utilize the following notion of an extended j-trace. Let (A1 , . . . , Am ), (α1,1 A1,1 , . . . , α1,m A1,m ), . . . (α1,1 α2,1 . . . αs,1 As,1 , . . . , α1,m α2,m . . . αs,m As,m ) be the sub-derivation corresponding to the j-th generative section of D(w). It yields the following extended version of the trace of the j-th generative section: ⎛ ⎞⎛ ⎞⎛ ⎞ ⎞ ⎛ αs,1 As,1 α1,1 A1,1 α2,1 A2,1 A1 ⎜ ⎟ ⎜ A2 ⎟ ⎜ α1,2 A1,2 ⎟ ⎜ α2,2 A2,2 ⎟ ⎟⎜ ⎟⎜ ⎟ . . . . . . ⎜ αs,2 As,2 ⎟ . ⎜ ⎝ ⎠ ⎝ ⎠ ⎠ ⎝ ··· ⎠⎝ ··· ··· ··· Am α1,m A1,m α2,m A2,m αs,m As,m This description is denoted ex-T (D(w), j). It describes the sequence of generative steps of the j-th generative section. Assume that D(w) has gk generative sections. Then ex-T (D(w)) = ex-T (D(w), 1), ex-T (D(w), 2), . . . , ex-T (D(w), gk ) is called the extended trace of D(w). Let us note that ex-T (D(w)) can serve as an another representation of D(w). The restarting automaton M processes the word wC as follows. In each cycle M first nondeterministically chooses an index j of a generative section, and then it consistently removes the rightmost generative cycle from each of the factors g(i, j) of w. Simultaneously, it checks the consistency of its guess and makes necessary changes in the delimiters. M repeatedly executes such cycles until a word is obtained that does not contain any generative cycles anymore. From Proposition 1 we see that the set of words of this form is finite.

On PCGS and Correctness Preserving Restarting Automata

667

Fig. 1. The situation before and after the execution of a cycle that makes rewrites within the j-th generative section: the reduced parts are grey. Two occurrences of g(1, j) were reduced to g  (1, j); one occurrence of g(2, j) was reduced to g  (2, j).

We show that we only need to store a constant amount of information in the auxiliary symbols to realize this strategy. Accordingly, the word wC is chosen as wC := Δ0,k Δ1,k g(i1 , j1 )Λ1,k Δ2,k g(i2 , j2 )Λ2,k . . . Δr,k g(ir , jr )Λr,k Δr+1,k , where Δ0,k , . . . , Δr+1,k and Λ1,k , . . . , Λr,k are auxiliary symbols. These symbols are not only used to separate the individual factors g(i, j) from each other, but ˆ k (w ˆk ). In also to store relevant information about the derivations D(w) and D fact, the information stored in each symbol Δt,k (0 ≤ t ≤ r + 1) will be fixed, while the information stored in each symbol Λt,k (1 ≤ t ≤ r) is temporary. The information stored in Δt,k describes the factor g(it , jt ) and the factor gˆ(it , jt ). The information stored in Λt,k will be changed whenever a deletion is executed in the left neighborhood of the particular delimiter; it describes a suffix of the relevant extended trace ex-T (D(w), jt ). By Λt,k (D(w)) we will denote the particular symbol that corresponds to this information.  If M has decided to try to execute a cycle, then it nondeterministically chooses a number j ∈ {1, . . . , gk } as the index of the generative section of D(w) that it will reduce in this cycle. It stores j and Δ0,k in its internal state and moves its head to the right until it reaches the first delimiter Δt,k for which jt = j holds, that is, the leftmost occurrence of a factor of the form g(i, j) is found. Then M moves its window further to the right until Δt,k becomes the leftmost symbol inside the window. Now M is going to try to simulate a reduction of the factor g(it , jt ) as described above. (1.) From the description of ex-T (Dˆk (wˆk )) stored in Δ0,k , M determines the nonterminal cut with which the extended j-trace ex-T (D(w), j) begins. (2.) Moving from left to right across the factor g(it , j), M guesses the extended j-trace ex-T (D(w), j) in such a way that it is consistent with the word g(it , j); if no such guess is possible, the computation is blocked. Simultaneously, M always remembers the current suffix t of length 2 · p(Π) of the part of ex-T (D(w), j) considered so far. Here p(Π) is a constant that is sufficiently large to ensure that any sub-word of any ex-T (D(w), j) of length at least p(Π) contains a generative cycle. (3.) When the delimiter Δt+1,k occurs as a rightmost symbol in M ’s window, then M tries to execute a reduction of the suffix of g(it , j); if none is possible, then the computation is blocked. To perform a reduction M checks whether the current suffix t of ex-T (D(w, j)) contains a (generative) cycle, that is, whether the suffix t,2 of t of length p(Π) has the following form:

668

D. Pardubská, M. Plátek, and F. Otto

⎛

⎞ ⎛ ⎞ ⎛ ⎞ ⎛ ⎞ α1,1 A1,1 αγ,1 Aγ,1 αγ+ν,1 Aγ+ν,1 αs ,1 As ,1 ⎜ α1,2 A1,2 ⎟ ⎜ αγ,2 Aγ,2 ⎟ ⎜ αγ+ν,2 Aγ+ν,2 ⎟ ⎜ αs ,2 As ,2 ⎟ ⎜ ⎟...⎜ ⎟...⎜ ⎟...⎜ ⎟ ⎝ ⎠ ⎝ ⎠ ⎝ ⎠ ⎝ ⎠ ··· ··· ··· ··· α1,m A1,m αγ,m Aγ,m αγ+ν,m Aγ+ν,m αs ,m As ,m such that Aγ,μ = Aγ+ν,μ for all μ = 1, . . . , m. If that is the case, and if t,2 coincides with the information stored in the symbol Λt,k (D(w)), then M removes the factor αγ+1,it · · · αγ+ν,it from g(it , j), it removes the corresponding cycle from t , which yields the suffix t of an extended j-trace, and it replaces the information stored in Λt,k by the suffix of t of length p(Π). Observe that the factor αγ+1,it · · · αγ+ν,it may well be empty, implying that this rewrite step simply replaces the symbol Λt,k by a new symbol Λt,k . Further, M stores t in its finite control, in order to be able to verify at later occurrences of factors of the form g(., j) that a consistent reduction is performed, and then M moves further to the right. If no further factor of the form g(., j) is encountered, then M restarts at the right end of the tape. If, however, another factor g(it , jt ) = g(i , j) is found, then M tries to reduce this factor in a way consistent with the reduction applied to g(it , j). Essentially, M processes the factor g(i , j) in the same way as g(it , j). However, on reaching the symbol Λt ,k it checks whether the current suffix t of the extended j-trace simulated coincides with the suffix t stored in its finite control. In the affirmative it can then perform the same replacement in Λt ,k that it performed on Λt,k , and it can reduce the factor g(i , j) in a way consistent with this replacement; otherwise, the computation is blocked.  of the  In an accepting tail M simply checks whether the current content wC tape belongs to the finite set of “shortest” characteristic words. From the description above it follows that M is a nondeterministic auxrewriting FRR-automaton, that the number of auxiliary symbols occurring in any restarting configuration of an accepting computation of M is bounded from above by the constant 2 · g · d + 2, and that M performs at most d rewrite steps in any cycle of any computation. Further, it is quite clear that LP (M ) = L holds. Finally, observe that M is in fact correctness preserving. For two different factors g(it , j) and g(it , j) it may guess different extended j-traces, but because of the information stored in Λt,k = Λt ,k , the suffixes of length 2 · p(Π) of these traces coincide. Thus, as long as the corresponding suffix of the extended jtrace considered coincides with Λt,k , the reduction performed is consistent with a valid derivation D(w). Further, if an inconsistency is discovered by M , then the computation is blocked immediately, that is, no further restart is performed.   ∈ LC (M ) if wC ∈ LC (M ) and wC cM wC hold, that is, M is It follows that wC indeed correctness preserving. This completes the proof of Theorem 1. 2

A detailed example with some additional explanations can be found in the technical report [4]. The AuxRR-automaton M described in the proof of Theorem 1 processes a given input by first choosing a particular derivation without cycles (and its communication structure) from among the finite set of possible derivations without

On PCGS and Correctness Preserving Restarting Automata

669

cycles by inserting delimiters. Then, in each cycle a specific generative section j is chosen nondeterministically, and the rightmost generative cycle is removed from each factor g(i, j). In fact, each rewrite operation of each cycle executed by M replaces an auxiliary symbol of the form Λ(D(w)) by another auxiliary symbol of the form Λ(D (w )), and there is at least one rewrite operation in each cycle that removes a non-empty factor consisting of input symbols4 . These observations motivate the following definition of a skeletal set. Definition 2. Let M = (Q, Σ, Γ, c, $, q0 , k, δ) be a t-AuxRR-automaton, r, s ∈ N+ , and let SP be a subalphabet of Γ of cardinality |SP | ≤ s · r · t. We call SP a skeletal set of type (r, t), if there is an injection φ : SP → {1, . . . , s} × {1, . . . , r} × {1, . . . , t} such that the properties below are satisfied: 1. Elements of SP are neither inserted, nor removed, nor changed during any computation of M ; accordingly, we call them islands. 2. For all w ∈ LC (M ) and all χ ∈ SP , |w|χ ≤ 1, that is, w contains at most one occurrence of χ. 3. For 1 ≤ i ≤ s, let SP (i) = { χ ∈ SP | φ(χ) = [i, a, b] } be the i-th skeleton of SP . For each word w ∈ LC (M ), there exists a unique index i ∈ {1, . . . , s} such that PrSP (w) ⊆ SP (i) holds. Thus, w only contains islands of a single skeleton. 4. Each rewrite operation O of M has the form xyzγχ → xzγ  χ, where xyz ∈ Σ ∗ , |y| ≥ 0, γ, γ  ∈ (Γ  (Σ ∪ SP )) are auxiliary symbols that are not islands, and χ ∈ SP is an island. The symbol χ is called the island visited by O. 5. For 1 ≤ i ≤ s and 1 ≤ j ≤ r, let SP (i, j) = { χ ∈ SP | φ(χ) = [i, j, b] }, which is the j-th level of the i-th skeleton of SP . Within a cycle of a computation of M , the level of a skeleton is kept fixed, that is, if a rewrite operation O is applied in a cycle such that the island visited by O is from SP (i, j), then for every rewrite operation executed during this cycle the island visited belongs to SP (i, j). 6. There exists a constant (M ) such that, for each w = xyz ∈ LC (M ), where |y| > (M ) and y does not contain any island, then starting from the restarting configuration corresponding to w, M will execute at least one cycle before it accepts. If SP is a skeletal set of type (r, t), then the auxiliary symbols in Γ  SP are called variables of M . Thus, Γ is partitioned into three disjoint subsets: the set of input symbols Σ, the skeletal set SP , and the set of variables. Based on the properties of a skeletal set the following result can be derived similarly as in [1]. Corollary 1 (SP semi-linearity). Let t ∈ N be a positive integer, and M be a t-AuxRR-automaton with a skeletal set. Then the languages LC (M ) and LP (M ) are semi-linear, that is, their Parikh images are semi-linear (see [5]). 4

All derivations considered are reduced.

670

D. Pardubská, M. Plátek, and F. Otto

Observe that the copy language Lcopy = { ww | w ∈ {a, b}∗ } can be generated by a returning PCGS with regular components and constant communication complexity, but that it cannot be generated by any centralized returning PCGS with regular components. Thus, Corollary 1 is not a special case of the corresponding result for the latter class of PCGSs given in [5]. Obviously, with almost no change the delimiters Δ0,k and Δ1,k in the proof of Theorem 1 can be shifted just before the delimiter Δ2,k . Thus, the set of delimiters of the form Θ1,k = (Δ0,k , Δ1,k , Δ2,k ), and Θt,k = Δt+1,k for t > 1, can serve as a skeletal set for a newly constructed automaton M  . The characteristic word wC from LC (M  ) will then be of the following form: wC := g(i1 , j1 )Λ1,k Θ1,k g(i2 , j2 )Λ2,k Θ2,k . . . g(ir , jr )Λr,k Θr,k . Corollary 2. For each L ∈ g-d-DDG, there exists a nondeterministic d-AuxRRautomaton M with a skeletal set SP of type (g, d) such that L = LP (M ). Each variable of w ∈ LC (M ) is positioned immediately to the left of an element of SP . The d-AuxRR-automaton M in Corollary 2 is inherently nondeterministic. To avoid this nondeterminism we now consider a slight generalization of the underlying FRR-automaton: the FRL-automaton. The FRL-automaton is obtained from the FRR-automaton by introducing move-left steps. For example, such an automaton can first scan its tape completely from left to right, then move back to the left end of the tape, and then perform some rewrite operations during a second left-to-right sweep. A d-AuxRL-automaton is an FRL-automaton that is aux-rewriting, correctness preserving, and that performs at most d rewrite operations in any cycle. Obviously, the d-AuxRR-automaton M from Corollary 2 can be seen as a dAuxRL-automaton of a restricted form. Hence, Theorem 3.4 in [6] applies, which states that there exists a deterministic d-FRL-automaton Mdet that accepts the same characteristic language as M . In fact, if w cMdet w , then also w cM w holds, and if w cM w , then w cMdet w for some word w . Since the transformation from M to Mdet in the proof of Theorem 3.4 in [6] does not change the existence of a skeletal set, we can restate Corollary 2 as follows. Corollary 3. For each L ∈ g-d-DDG, there exists a deterministic d-AuxRLautomaton M with a skeletal set SP of type (g, d) such that L = LP (M ). Moreover, in each wC ∈ LC (M ) each variable is positioned immediately to the left of an element of SP . Let M be a deterministic d-FRL-automaton. Given an input w of length n, M will execute at most n cycles, before it either accepts or rejects. Each of these cycles requires a number of steps that is linear in n. It follows that the membership problem for the language LC (M ) is decidable in quadratic time. If M is a deterministic d-AuxRL-automaton with a skeletal set SP of type (g, d), then an input word w of length n belongs to the proper language LP (M ), if there exists an extended variant wC of w that is in the characteristic language LC (M ). From the form of the skeletal set we see that wC is obtained from

On PCGS and Correctness Preserving Restarting Automata

671

w by inserting at most g · d factors of the form λδ, where λ is a variable and δ is an island. Hence, there are O(|Γ  Σ|2·g·d · ng·d ) many candidates for wC . They can all be enumerated systematically, and then for each of them membership in LC (M ) can be tested in time O((n + 2 · g · d)2 ). Thus, we obtain the following. Proposition 2. Let M be a deterministic d-AuxRL-automaton with a skeletal set SP of the type (g, d) such that each variable in wC ∈ LC (M ) is positioned immediately to the left of an element of SP . Then, for each w ∈ Σ ∗ , the size of AC (w, M ), the characteristic analysis of w by M , is at most O(|Γ Σ|2·g·d ·ng·d ), and this set can be computed in time O(|Γ  Σ|2·g·d · ng·d · (n + 2 · g · d)2 ). This proposition together with Corollary 3 has the following consequence. Corollary 4. For each language L ⊆ Σ ∗ , if L ∈ g-d-DDG, then there exists a d-AuxRR-automaton M such that L = LP (M ), and for each w ∈ Σ ∗ , the size of the set AC (w, M ) is at most O(|Γ  Σ|2·g·d · ng·d ), and it can be computed in time O(|Γ  Σ|2·g·d · ng·d · (n + 2 · g · d)2 ). Concluding remarks. Similar results as in this paper can be derived for PCGSs with linear-grammar components. On the other hand, that will surely not be the case for PCGSs with context-free components. Let us note that a polynomial upper bound for the (simple) membership problem for returning PCGSs with regular components already follows from [7]. Some results illustrating the generative power of the classes of PCGSs considered here are given already in [2] by the use of a deterministic variant of FRR-automata.

References 1. Pardubská, D., Plátek, M.: Parallel communicating grammar systems and analysis by reduction by restarting automata. In: Bel-Enguix, G., Jimenez-Lopez, M. (eds.) ForLing 2008. Proc. Research Group on Mathematical Linguistics, pp. 81–98. Universitat Rovira i Virgili, Tarragona (2008) 2. Pardubská, D., Plátek, M., Otto, F.: On PCGS and FRR-automata. In: Vojtáš, P. (ed.) ITAT 2008, Proc. Pavol Jozef Šafárik University, Košice, pp. 41–47 (2008) 3. Lopatková, D., Plátek, M., Sgall, P.: Towards a formal model for functional generative description - analysis by reduction and restarting automata. The Prague Bulletin of Mathematical Linguistics 87, 7–26 (2007) 4. Pardubská, D., Plátek, M., Otto, F.: On parallel communicating grammar systems and correctness preserving restarting automata. Kasseler Informatikschriften, Universität Kassel (2008), https://kobra.bibliothek.uni-kassel.de/bitstream/ urn:nbn:de:hebis:34-2008111825149/3/Technicalreport2008_4.pdf 5. Czuhaj-Varjú, E., Dassow, J., Kelemen, J., Pˇ aun, G. (eds.): Grammar Systems: A Grammatical Approach to Distribution and Cooperation. Gordon and Breach Science Publishers (1994) 6. Messerschmidt, H., Otto, F.: On determinism versus nondeterminism for restarting automata. Information and Computation 206, 1204–1218 (2008) 7. Cai, L.: The computational complexity of PCGS with regular components. In: Dassow, J., Rozenberg, G., Salomaa, A. (eds.) Proc. of DLT 1995, pp. 209–219. World Scientific, Singapore (1996)

Finitely Generated Synchronizing Automata Elena V. Pribavkina1, and Emanuele Rodaro2, 1 Ural State University, 620083, Ekaterinburg, Russia Universit´ a dell’Insubria, Via Valleggio 11, 22100 Como, Italy [email protected], [email protected] 2

Abstract. A synchronizing word w for a given synchronizing DFA is called minimal if no proper prefix or suffix of w is synchronizing. We characterize the class of synchronizing automata having finite language of minimal synchronizing words (such automata are called finitely generated ). Using this characterization we prove that any such automaton possesses a synchronizing word of length at most 3n − 5. We also prove that checking whether a given DFA A is finitely generated is co-NPhard, and provide an algorithm for this problem which is exponential in the number of states A .

1

Introduction

A synchronizing automaton A = Q, Σ, δ is a deterministic and complete finitestate automaton (DFA) possessing a synchronizing word, that is a word w which takes all states of A to a particular one: δ(q, w) = δ(q  , w) for all q, q  ∈ Q. By L (A ) we denote the language of all words synchronizing A . Over the past forty years synchronizing automata and especially shortest synchronizing words have been widely studied, motivated mostly by the famous ˇ Cern´ y conjecture [1] which states that any n-state synchronizing automaton possesses a synchronizing word of length at most (n − 1)2 . This conjecture has been proved for a large number of classes of synchronizing automata, nevertheless in general it remains one of the most longstanding open problems in automata theory. For more details see the surveys [2,3,4]. In this paper we deal with minimal synchronizing words which in some sense generalize the notion of a shortest synchronizing word. Namely, a synchronizing word is called minimal if none of its proper prefixes nor suffixes is synchronizing. It is obvious that the language L (A ) of all synchronizing words is a two-sided ideal generated by the language Lmin (A ) of all minimal synchronizing words: L (A ) = Σ ∗ Lmin (A )Σ ∗ . Thus it is rather natural to consider the class of synchronizing automata whose language of minimal synchronizing words is finite. Such automata are referred to as finitely generated synchronizing automata and  

The author acknowledges support from CIMO Fellowship Programme TM-07-5127 during her stay at the University of Turku, Finland. Part of this work was done during the two visits of the second named author to the Ural State University. These visits were partially supported by the ESF project Automatha and the group GNSAGA of INDAM.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 672–683, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Finitely Generated Synchronizing Automata

673

the class of such automata is denoted by FG. In Section 3 we give a characterization of this class. Moreover using the characterization we prove in Section 4 that the shortest synchronizing word for such automata has length at most 3n − 5. Example 1. Let Σ = {a, b} and consider the minimal automaton A recognizing the language L = Σ ∗ abaΣ ∗ (see Fig. 1.) b

1

a, b

a a

2

b

3

a

4

b Fig. 1. Automaton A recognizing L = Σ ∗ abaΣ ∗

It is easy to see that A is synchronizing, and L (A ) = L, thus Lmin (A ) = {aba}, so A ∈ FG. Analogously for any w ∈ Σ ∗ the minimal automaton recognizing Σ ∗ wΣ ∗ is finitely generated. Moreover it is well-known that this automaton has n = |w|+1 states, hence its minimal synchronizing word is of length n−1. Clearly, in general, the minimal automaton recognizing the language Σ ∗ M Σ ∗ for a finite language M is finitely generated. Another natural question arising in this contest is whether testing A ∈ FG is decidable. An easy argument shows that the answer is “yes”. Indeed, in general, for a given language L, we can consider the set Lmin of its minimal words. Analogously it is the set of words from L such that none of its proper prefixes nor suffixes belongs to L. It is not hard to see that Lmin = L \ (Σ + L ∪ LΣ + ). In particular, if L is a two-sided ideal, this expression reduces to: Lmin = L \ (ΣL ∪ LΣ).

(1)

Observe that if L is a regular language and it is represented by an n-state DFA, then clearly Lmin is also a regular language recognized by an automaton with O(n3 ) states, and it is easy to see that checking finiteness of Lmin takes O(n6 ) operations. In framework we are dealing the language of synchronizing words of a given automaton A is well known to be regular (it is recognized by the power automaton P(A ) with Q as an initial state and singletons as terminal ones). Thus the language L (A ) of an n-state synchronizing automaton A is recognized by an automaton with at most 2n states. Hence by (1) the language Lmin (A ) is regular and checking whether A ∈ FG takes O(26n ) operations. Therefore one may ask whether checking finiteness of the language of minimal synchronizing words is indeed a hard task and if there are better algorithms than the naive one. We formally state the FINITENESS problem: – Input : A synchronizing DFA A = Q, Σ, δ. – Question: Is the language Lmin (A ) finite?

674

E.V. Pribavkina and E. Rodaro

Our characterization gives rise to another algorithm for solving FINITENESS which is a slight improvement of the naive one, it is discussed in Section 3. Furthermore in Section 5 we show that FINITENESS is co-NP-hard. So the problem is not likely to have a polynomial time algorithm. Pawel Gawrychowski [5] has shown that this problem is in PSPACE, but we are not aware whether it belongs to some lower complexity class.

2

Preliminaries

We fix a synchronizing DFA A = Q, Σ, δ. For convenience for each v ∈ Σ ∗ and q ∈ Q we will write q . v = δ(q, v) and put S . v = {q . v | q ∈ S} for any S ⊆ Q. A subset S of Q is called reachable if there is a word v ∈ Σ ∗ with S = Q . v. Given a subset S of Q by C(S) we denote the set of all words stabilizing S: C(S) = {w ∈ Σ ∗ | S . w = S}. By R(S) we denote the set of all words bringing S to a singleton: R(S) = {w ∈ Σ ∗ | |S . w| = 1}. Note that L (A ) is contained in R(S) for any S. Lemma 1. Given a word w ∈ Σ ∗ there exists an integer β ≥ 0 such that the set m(w) = Q . wβ is fixed by w. Moreover m(w) is the largest subset of Q with this property. Proof. Consider the sets Q . wα ⊆ Q for any α ≥ 0. Since the number of subsets of Q is finite, there are β ≥ 0 and γ > 0 such that Q . wβ = Q . wβ+γ . It is easy to see that Q . wβ ⊇ Q . wβ+1 ⊇ . . . ⊇ Q . wβ+γ = Q . wβ . Hence all inclusions are in fact equalities and in particular Q . wβ+1 = Q . wβ , so the set Q . wβ is fixed by the word w. On the other hand take any S ⊆ Q fixed by w, then applying w we obtain S = S . w ⊆ Q . w, . . . , S = S . wβ ⊆ Q . wβ , so m(w) is the largest subset fixed by the word w.

2

Given a word w, the subset m(w) of Q from the previous Lemma is called the maximal fixed set with respect to w. Let k(w) be the least integer with the property Q . wk(w) = m(w). Then we have the following Lemma 2. Given a word w ∈ Σ ∗ k(w) ≤ |Q| − |m(w)|.

Finitely Generated Synchronizing Automata

675

Proof. We have |Q . wβ+1 | < |Q . wβ | for any 0 ≤ β < k(w). Indeed, suppose |Q . wβ+1 | = |Q . wβ | for some 0 ≤ β < k(w). Since Q . wβ+1 ⊆ Q . wβ we have Q . wβ+1 = Q . wβ , hence Q . wβ ⊆ m(w). On the other hand, m(w) = Q . wk(w) ⊆ Q . wβ , thus m(w) = Q . wβ , which is a contradiction with the choice of k(w). Therefore |Q| > |Q . w| > . . . > |Q . wk(w) |, and |Q . wk(w) | ≤ |Q| − k(w), hence k(w) ≤ |Q| − |m(w)|. 2 Lemma 3. Given a word w ∈ Σ ∗ and α ∈ N m(wα ) = m(w). Proof. Obviously wα ∈ C(m(w)) for any α ∈ N, hence m(w) ⊆ m(wα ). Conversely, by Lemma 1 m(wα ) = Q . wαβ for some β ≥ 0. Since m(wα ) is fixed by wα , we have |m(wα ) . wα | = |m(wα )| in particular; thus |m(wα ) . w| = |m(wα )| and hence |Q . wαβ+1 | = |Q . wαβ |. On the other hand, Q . wαβ+1 ⊆ Q . wαβ , thus Q . wαβ+1 = Q . wαβ , so m(wα ) is fixed by w as well, and m(wα ) ⊆ m(w). Therefore m(wα ) = m(w). 2

3

The Class FG

In this section we characterize the class FG and provide another algorithm for checking whether a given DFA is in FG. Theorem 1. Given a synchronizing DFA A = Q, Σ, δ the following are equivalent: (i) A ∈ FG (ii) for any reachable subset S ⊆ Q such that 1 < |S| < |Q|, for each w ∈ C(S) R(S) = R(m(w)). Proof. (i) ⇒ (ii). Consider an arbitrary reachable subset S ⊂ Q with 1 < |S| < |Q|. If C(S) = ∅ then there is nothing to prove, so we can assume that C(S) = ∅ and take an arbitrary w ∈ C(S). Note, that the inclusion R(m(w)) ⊆ R(S) always holds true. Indeed, the set S is contained in the maximal fixed set m(w), and all the words synchronizing the set m(w) synchronize also S. In case R(S) = L (A ) we have L (A ) ⊆ R(m(w)) ⊆ L (A ), therefore R(m(w)) = L (A ), and the equality holds. Suppose now that R(S) = L (A ). It means that there exists a word v which brings the set S to a singleton, but does not synchronize the whole automaton. On the other hand, since the set S is reachable there exists a word u such that S = Q . u. Consider now the infinite sequence of words uwi v for i ≥ 0. Note that these words are synchronizing, and since Lmin (A ) is finite, among them there can be only a finite number of minimal synchronizing words. By the choice of u and w such a minimal synchronizing word always contains a prefix of v as a suffix. Note also that if all the minimal synchronizing words in the given sequence would start with some suffix of u, then there would be an infinite sequence of

676

E.V. Pribavkina and E. Rodaro min v

u

w

u

w

u

w w

min w v ... ...

min w v

Fig. 2. Finite Sequence of Minimal Synchronizing Words

minimal synchronizing words ui wi v where u = ui ui for i = 0, 1, 2 . . .. Therefore there exists a positive integer β such that the word wβ v is synchronizing (not necessarily minimal, see Fig. 2). By Lemma 1 as β we can choose an integer such that Q . wβ = m(w), thus v brings this set to a singleton. Thus if the language Lmin (A ) is finite then R(S) ⊆ R(m(w)). Since the opposite inclusion always holds true, we have R(S) = R(m(w)). (ii) ⇒ (i). Arguing by contradiction suppose that the condition (ii) holds, but Lmin (A ) is infinite. Since this language is regular, applying the pumping lemma we have that any long enough word in Lmin (A ) can be factorized as uwv so that w = 1 (where 1 denotes the empty word) and uwα v is in Lmin (A ) for any integer α ≥ 0. If u = 1 then wα v ∈ Lmin (A ) for all α ≥ 0, in particular for α = 0 we obtain that the word v is synchronizing, but this means that the words wα v do not belong to Lmin (A ), a contradiction. Analogously we get a contradiction in case v = 1. Thus we may assume that both u and v are non-empty words. Consider sets Q . uwα for α ≥ 0. Since uwα v is minimal synchronizing, we have 1 < |Q . uwα | < |Q|. Since the number of subsets of Q is finite there are integers α0 ≥ 0 and γ > 0 such that Q . uwα0 = Q . uwα0 +γ . Put S = Q . uwα0 . This set is fixed by wγ , so by (ii) we have R(S) = R(m(wγ )), with m(wγ ) = Q .(wγ )β for some β ≥ 0. Since v ∈ R(S) we have v ∈ R(m(wγ )), so |Q . wγβ v| = 1. Therefore the word wγβ v is synchronizing and for α > γβ the word uwα v does not belong to the language Lmin (A ), again a contradiction. Thus the language Lmin (A ) is finite. 2 Corollary 1. Let A = Q, Σ, δ be a synchronizing automaton such that there is a letter a ∈ Σ with Q . a = Q and there are no letters b ∈ Σ with |Q . b| = 1. Then Lmin (A ) is infinite. Proof. Consider the shortest synchronizing word w for the automaton A . Since no letter is synchronizing we have w = xv with x ∈ Σ, v ∈ Σ + , and 1 < |Q . x| < Q. Since a is a permutation letter it is clear that aα ∈ C(Q . x) for some positive integer α. On the other hand Q . aα = Q, hence m(aα ) = Q. Note that R(Q . x) = R(Q) since v ∈ R(Q . x) but not in R(Q) = L (A ) (otherwise it would be a shorter synchronizing word). Thus by Theorem 1 the language 2 Lmin (A ) is infinite. Theorem 1 gives rise to an algorithm FinCheck different from the straightforward one presented in section 1 for the problem of recognizing finitely

Finitely Generated Synchronizing Automata

677

generated synchronizing automata. Actually Theorem 1 says that for a given reachable subset S of Q for all the words w ∈ C(S) we must check whether R(S) = R(m(w)). The problem is that the set C(S) might be infinite. On the other hand there are only finitely many subsets of Q of the form m(w) for all w ∈ C(S). So for a given S we can check the property of Theorem 1 for all the subsets T of Q containing S with C(S)∩C(T ) = ∅. Indeed, obviously among such subsets there are those of the form m(w) for all possible w. So if R(S) = R(T ) for all such T , then the condition of the theorem holds. If R(S) = R(T ) for some T ⊇ S, then it does not hold for m(w) either, w ∈ C(S) ∩ C(T ) = ∅, since T ⊆ m(w). Now we present the algorithm. FinCheck(A ): 1 From the DFA A = Q, Σ, δ construct its power automaton P(A ) consisting only of subsets reachable from Q. 2 For each state S of P(A ) do: 2.1 For each T of P(A ) with S ⊆ T do: 2.2 If C(T ) ∩ C(S) = ∅, then 2.3 If R(T ) = R(S), then exit and return NO 3 Otherwise exit and return YES  technical calculation shows that the cost of this algorithm is of A rather O 22n 3n operations, so it is slightly better than the straight-forward algorithm but still is exponential in the number of states of the initial automaton.

4

ˇ Cern´ y’s Conjecture for the Class FG

Using the characterization from the previous section here we show a linear upper bound on the length of the shortest synchronizing word for the class of finitely generated synchronizing automata. Recall that the deficiency of a word w ∈ Σ ∗ with respect to a given automaton A = Q, Σ, δ is the difference df(w) = |Q|−|Q . w|. We make use of the following result from [6] (see also [7]): Theorem 2. Given a synchronizing automaton A = Q, Σ, δ and the words u, v ∈ Σ + such that df(u) = df(v) = k > 1, there exists a word τ , with |τ | ≤ k+1, such that df(uτ v) > k. Theorem 3. Let A = Q, Σ, δ be a finitely generated synchronizing automaton with n states. There is a synchronizing word of length at most 3n − 5. Proof. Take any a ∈ Σ. By Corollary 1, if a acts as a permutation on the state set Q, then there exists a synchronizing letter b, so the statement of the theorem trivially holds. Thus we can assume that a is not a permutation letter, thus Q . ak(a) = m(a)  Q. Suppose first that |m(a)| = 1, then 1 = |m(a)| = |Q . ak(a) | and by Lemma 2, k(a) ≤ n − |m(a)| = n − 1 ≤ 3n − 5 for n ≥ 2.

678

E.V. Pribavkina and E. Rodaro

Now suppose that |m(a)| > 1, and consider non-singleton subsets of m(a) reachable from m(a): Reach(a) = {S ⊆ m(a) | S = m(a) . u, u ∈ Σ ∗ , |S| > 1}. Obviously m(a) ∈ Reach(a), so Reach(a) is not empty. Also note that for any S ∈ Reach(a) it holds R(S) = R(m(a)). (2) Indeed, since S ⊆ m(a) we have aα ∈ C(S) for some α ∈ N. Then since A is finitely generated applying Theorem 1 and Lemma 3 we get R(S) = R(m(aα )) = R(m(a)) Now let H = Q . ak(a) u be an element of Reach(a) of minimal cardinality and let k  = n − |H| = df (ak(a) u). Since |H| > 1 we have k  ≤ n − 2. Since A is synchronizing, there exists a word of deficiency n − 1, therefore by Theorem 2 there is a word τ with |τ | ≤ k  + 1 such that df(ak(a) uτ ak(a) u) > k  , i.e. |Q . ak(a) uτ ak(a) u| < |H|. Next we prove that the word ak(a) uτ ak(a) uaka is synchronizing. Indeed, suppose on the contrary that |Q . ak(a) uτ ak(a) uak(a) | > 1. It is easy to see that Q . ak(a) uτ ak(a) uak(a) ⊆ m(a), hence Q . ak(a) uτ ak(a) uak(a) ∈ Reach(a). However the inequality |Q . ak(a) uτ ak(a) uak(a) | ≤ |Q . ak(a) uτ ak(a) u| < |H| contradicts the choice of H. In fact even the word ak(a) uτ ak(a) is synchronizing. Indeed, consider the set S = Q . ak(a) uτ ak(a) . If |S| > 1 then S ∈ Reach(a), hence uak(a) ∈ R(S) = R(m(a)), so 1 = |m(a) . uak(a) | = |H . ak(a) |. But by the choice of H we have |H . ak(a) | = |H| > 1, which is a contradiction. Thus τ ak(a) ∈ R(Q . ak(a) u) = R(H) = R(m(a)) = R(Q . ak(a) ), hence the word ak(a) τ ak(a) is synchronizing and |ak(a) τ ak(a) | ≤ 2k(a) + k  + 1 ≤ 2(n − 2) + n − 1 = 3n − 5. 2 Remark 1. Under conditions of the Theorem 3 if k = min k(a), then there is a synchronizing word of length at most 2k + n − 1.

5

a∈Σ

Co-NP-Hardness

In this section we prove that the FINITENESS problem for a given DFA is coNP-hard. To prove the result we introduce another problem which we refer to as REACHABILITY. Formally: Input : A DFA A = Q, Σ, δ and a subset H ⊆ Q. Question: Is there a word w ∈ Σ ∗ such that Q . w = H? The proof proceeds in two stages. First we show that any instance from a particular set I of instances of REACHABILITY can be polynomially reduced to an

Finitely Generated Synchronizing Automata

679

instance of the complement of FINITENESS. Next we complete the proof by polynomially reducing any instance of SAT to an instance of REACHABILITY belonging to I. In our reductions we essentially make use of a particular class of automata, called nilpotent automata. This notion was introduced by Perles et al. in 1962 under the name of definite table [8]. Later such automata were studied by Rystsov ˇ in [9] in view of Cern´ y’s conjecture. In the present paper we use the definition from [9]. Namely, we say that a DFA A = Q, Σ, δ is nilpotent if there is a state q ∈ Q and a positive integer n such for any word w ∈ Σ ∗ of length at least n it holds Q . w = {q}. Obviously any nilpotent automaton is synchronizing with a sink state, i.e. the state fixed by all the letters of the alphabet (q in the definition). In the following lemma we state without proof some simple known properties of nilpotent automata. Lemma 4. Let A = Q, Σ, δ be a DFA with a unique sink state. (1) If A is nilpotent, then for any word w ∈ Σ + there exists a positive integer m such that Q . wm = {q}. (2) A is nilpotent iff there are no cycles or loops passing through non-sink states. Next we introduce a particular subclass of nilpotent automata and a particular set I of instances of REACHABILITY. Consider a nilpotent automaton A = Q, Σ, δ with a sink state p and a non-empty set RA of states r satisfying the following conditions: – r . Σ = p; – if there exists a word w such that Q . w = {p, r}, then there exists such word of length at least 2. We denote this class of automata by N . Note that the language Lmin (A ) is finite for every A ∈ N . It is an easy consequence of Theorem 1 and Lemma 4. The set I is defined as follows: I = {(A , H) | A ∈ N , H = {p, r}, r ∈ RA }. The next proposition polynomially reduces any instance of REACHABILITY belonging to I to an instance of the complement of FINITENESS. Its proof is rather technical and due to the space limitation is omitted here. Proposition 1. Let (A , H) ∈ I be an instance of REACHABILITY, with A = Q, Σ, δ and H = {p, r}, r ∈ RA . Then there is a synchronizing automaton A  such that the language Lmin (A  ) is infinite if and only if there exists w ∈ Σ + such that Q . w = H. In the sequel we polynomially reduce an instance of SAT to an instance of REACHABILITY belonging to I. To this end we present another auxiliary construction. Recall that a cartesian product of n deterministic finite automata

680

E.V. Pribavkina and E. Rodaro

Ai = Qi , Σ, δi  is a DFA ×ni=1 Ai = Q, Σ, δ with Q = Q1 × Q2 × · · · × Qn , and a transition function δ : Q × Σ → Q defined component-wise δ((q1 , q2 , . . . , qn ), a) = (δ1 (q1 , a), δ2 (q2 , a), . . . , δn (qn , a)). Clearly this action extends in a natural way to the free monoid Σ ∗ . It is not difficult to check that the following statement holds Lemma 5. Let A1 , . . . , Am be nilpotent automata over a fixed alphabet with the sink states q1 , . . . , qm respectively. Then their cartesian product ×m i=1 Ai is also nilpotent with a sink state q = (q1 , . . . , qm ). Next we fix a positive integer n ≥ 2 and for each such n construct two particular nilpotent automata over the alphabet Σn = {a1 , b1 , . . . , an , bn }. For convenience let γi = {ai , bi } (in the sequel γi will correspond to the two possible values for the ith variable). Consider an automaton An = QA , Σn , δA  with QA = {0, 1, . . . , n, p1 } and the transition function defined as follows (Fig. 3): i . γi+1 = i + 1 for 0 ≤ i ≤ n − 1, i . (Σn \ γi+1 ) = p1 for 0 ≤ i ≤ n − 1, n . Σn = p1 , p1 . Σn = p1 . a 1 , b1 0

Σn \ γ1

Σn

a 2 , b2

1

... Σn \ γ2

p1

Σn Σn \ γn

n a n , bn n − 1 Fig. 3. Automaton An

Next let Bn = QB , Σn , δB  with QB = {0, 1, . . . , n} and the following transition rules (Fig. 4): i . Σn = i + 1 for 0 ≤ i ≤ n − 1 and n . Σn = n. Σn 0

Σn

1

Σn

...

n−1

Σn

n

Fig. 4. Automaton Bn

Now we construct their cartesian product Vn = An × Bn which has (n + 1)(n + 2) states and will serve as a gadget encoding the correct assignment of the values to variables. The following proposition establishes the main properties of this automaton.

Finitely Generated Synchronizing Automata

681

Proposition 2. The automaton Vn = An × Bn = QA,B , Σn , δA,B  is nilpotent with the sink state p = (p1 , n) and the state r = (n, n) satisfies r . Σn = p. Moreover QA,B . w = {p, r} if and only if w = x1 . . . xn with xi ∈ γi . Proof. By Lemma 5 Vn is nilpotent with the sink state p = (p1 , n). The state r = (n, n) satisfies r . Σn = p. Suppose that QA,B . w = {p, r} = {p1 , n} × {n}. It is obvious that for any word w it holds QA,B . w = QA . w × QB . w. Thus we have QA . w = {p1 , n} and QB . w = {n}. An inspection of the automaton Bn shows that QB . w = {n} if and only if |w| ≥ n. Suppose that w = xj w for some xj ∈ γj , then by the definition of the automaton An , we get QA . xj = {p1 , j}. Hence, not to kill the state j and to lead it till the state n, we must have w = xj xj+1 . . . xn , xi ∈ γi for all i ≥ j. Combining this with the condition |w| ≥ n we get j = 1, i.e. w = x1 . . . xn with xi ∈ γi for all i ≥ 1. Conversely, let w = x1 . . . xn with xi ∈ γi . An easy computation shows that QA . w = {n, p1 } and QB . w = {n}. Thus {p, r} = {p1 , n} × {n} = QA . w × QB . w = QA,B . w = {p, r}. 2 Let an instance of SAT consist of m clauses χ = {c1 , . . . , cm } over n variables X1 , . . . , Xn . Without loss of generality we can assume n ≥ 2. Next for each xi ∈ γi = {ai , bi }, 1 ≤ i ≤ n we define χ(xi ) = {ci1 , . . . , cik } to be the subset of χ consisting of clauses which contain positive literal Xi if xi = ai , and of clauses containing negative literal ¬Xi if xi = bi . Without loss of generality we can assume that χ(ai ) ∩ χ(bi ) = ∅, otherwise the common clause ck ∈ χ(ai ) ∩ χ(bi ) would contain both Xi and ¬Xi , and so it would be trivially satisfied. Moreover we can assume that all such subsets are non-empty. Indeed if some χ(ai ) = ∅, then all the clauses contain only negative literal ¬Xi , hence we can put Xi = 0 and reduce the problem to one with less variables. We say that the set {x1 , . . . , xn } with xi ∈ γi for i = 1, . . . , n is a satisfiable assignment for χ if and only if n 

χ(xi ) = χ.

i=1

With these definitions, it is clear that to a satisfiable assignment {x1 , . . . , xn } corresponds a satisfiable assignment for the Boolean formula ∧m i=1 ci given by Xi = 1 if xi = ai , and Xi = 0 if xi = bi , and vice versa. We now define a nilpotent automaton S(c1 , . . . , cm ) = S, Σn , Δ associated to the clauses c1 , . . . , cm . This automaton is a gadget which chooses satisfiable assignments from all possible ones. This automaton has m(n + 1) + 1 states with S = χ1 ∪ χ2 ∪ . . . χn ∪ χ ∪ {p } where χi = {ci1 , . . . , cim } for i = 1, . . . , n are copies of χ = {c1 , . . . , cm }. We denote by χi (xk ) the subset of χi which is the corresponding copy of χ(xk ). The action of Δ on S is defined as follows. For each 1 ≤ i ≤ n − 1, each 1 ≤ j ≤ m, and cij ∈ χi we have ∈ χi+1 , if cij ∈ χi (ai ) then cij . ai = p , and cij .(Σn \ {ai }) = ci+1 j i+1 i i i  i if cj ∈ χ (bi ) then cj . bi = p and cj .(Σn \ {bi }) = cj ∈ χi+1 ,

682

E.V. Pribavkina and E. Rodaro

if cij ∈ χi \ (χi (ai ) ∪ χi (bi )) then cij . Σn = ci+1 ∈ χi+1 ; j n n n  n if cj ∈ χ (an ) then cj . an = p and cj .(Σn \ {an }) = cj ∈ χ, if cnj ∈ χn (bn ) then cnj . bn = p and cnj .(Σn \ {bn }) = cj ∈ χ, if cnj ∈ χn \ (χn (an ) ∪ χn (bn )) then cnj . Σn = cj ∈ χ, χ . Σn = p and p . Σn = p . Clearly S(c1 , . . . , cm ) is nilpotent with the sink state p . The property stated in the following lemma is rather clear from the construction, thus we omit here the formal proof: Lemma 6. Let S(c1 , . . . , cm ) = S, Σn , Δ be constructed as above and w = x1 . . . xn ∈ Σn+ be a word with xi ∈ γi for i = 1, . . . , n, then S . w = {p } if and only if x1 , . . . , xn is a satisfiable assignment. Proposition 3. Let c1 , . . . , cm be clauses over n ≥ 2 variables. The automaton A = Vn ×S(c1 , . . . , cm ) = Q, Σn , δ belongs to N . Moreover, putting p = (p, p ), r = (r, p ), and H = {p, r}, we have (A , H) ∈ I and there is a word w ∈ Σn+ such that Q . w = H if and only if the Boolean formula ∧m i=1 ci is satisfiable. Proof. By Lemma 5, A = Q, Σn , δ is nilpotent since both Vn and S(c1 , . . . , cm ) are nilpotent automata. Moreover, with the notation of Proposition 2, p = (p, p ) is the sink state for A and since r . Σn = p and p . Σn = p , we obtain that the state r = (r, p ) satisfies r . Σn = p. Let us first prove that Q . w = H = {p, r} if and only if ∧m i=1 ci is satisfiable. Since {p, r} = {p, r} × {p }, then Q . w = QA,B . w × S . w. Thus Q . w = H if and only if QA,B . w = {p, r} and S . w = {p }. On the other hand, by Proposition 2, QA,B . w = {p, r} if and only if w = x1 . . . xn with xi ∈ γi for i = 1, . . . , n and, by Lemma 6, S . w = {p } if and only if {x1 , . . . , xn } is a satisfiable assignment. Now we prove that RA is not empty. By its definition if there is a word w such that Q . w = {p, r}, then the previous argument and the condition n ≥ 2 imply |w| ≥ 2. So r ∈ RA , hence A ∈ N . 2 Now we are ready to state the main theorem of this section. Theorem 4. The problem FINITENESS is co-NP-hard. Proof. Let {c1 , . . . , cm } be an instance of SAT with X1 , . . . , Xn variables, n ≥ 2. Combining Propositions 1 and 3 we obtain the automaton A  = Q , Σn , δ   over an alphabet with 2n + 1 symbols and having (n + 1)(n + 2)(m(n + 1) + 1) + 2 2 states, such that Lmin (A  ) is infinite if and only if ∧m i=1 ci is satisfiable. Remark 2. Note that in our reduction the size of the alphabet is not constant and depends on the input. In fact choosing the following coding ϕ of letters from Σn in words of length n over a binary alphabet ϕ(ai ) = 1i 0n−i ;

ϕ(bi ) = 0i 1n−i ,

i = 1, 2, . . . , n

gives our co-NP-hardness result also in case of a constant-size alphabet. The proof of the result is rather technical, so we omit it here.

Finitely Generated Synchronizing Automata

6

683

Open Problems

Theorem 3 shows that every n-state finitely generated synchronizing automaton has a synchronizing word of length at most 3n − 5. On the other hand, as discussed in the introduction, there are examples of automata in FG having shortest synchronizing words of length n− 1. We are interested in finding a series of finitely generated synchronizing automata whose shortest synchronizing word has length exactly 3n − 5 or proving that this length is always not greater than n − 1. Another interesting question concerns the precise complexity class of the problem FINITENESS. In particular, is it in co-NP? Let A ∈FG. Since the language Lmin (A ) is finite, one may ask how many elements it might have? Another problem is to give a bound for the length of the longest word in Lmin (A ).

Acknowledgement The authors thank professor Mikhail V.Volkov for proposing the problem and for the precious suggestions. They deeply appreciate useful remarks by professor Juhani Karhum¨ aki and are grateful to Pawel Gawrychowski for communicating them his PSPACE result. They also thank anonymous referees for careful reading of the paper and a number of helpful remarks.

References ˇ 1. Cern´ y, J.: Pozn´ amka k homog´ennym eksperimentom s koneˇcn´ ymi automatami. ˇ Mat.-Fyz. Cas. Slovensk. Akad. Vied. 14, 208–216 (1964) (in Slovak) ˇ 2. Mateescu, A., Salomaa, A.: Many-valued truth functions, Cern´ y’s conjecture and road coloring. EATCS Bull. 68, 134–150 (1999) 3. Sandberg, S.: Homing and synchronizing sequences. In: Broy, M., Jonsson, B., Katoen, J.-P., Leucker, M., Pretschner, A. (eds.) Model-Based Testing of Reactive Systems. LNCS, vol. 3472, pp. 5–33. Springer, Heidelberg (2005) ˇ 4. Volkov, M.V.: Synchronizing automata and the Cern´ y conjecture. In: Mart´ın-Vide, C., Otto, F., Fernau, H. (eds.) LATA 2008. LNCS, vol. 5196, pp. 11–27. Springer, Heidelberg (2008) 5. Gawrychowski, P.: Finiteness problem for the language of minimal synchronizing words is in pspace. Private Communication (2008) 6. Pin, J.E.: Utilisation de l’alg`ebre lin´eaire en th´eorie des automates. Actes du 1er Colloque AFCET-SMF de Math´ematiques Appliqu`ees, AFCET, Tome II, 85–92 (1978) (in French) 7. Margolis, S.W., Pin, J.E., Volkov, M.V.: Words guaranteeing minimum image. Int. J. Foundations Comp. Sci. 15(2), 259–276 (2004) 8. Perles, M., Rabin, M.O., Shamir, E.: The theory of definite automata. IEEE Trans. Electr. Comp. 12(3), 233–243 (1963) 9. Rystsov, I.K.: Resetting words for decidable automata. Cybernetics and Systems analysis 30(6), 807–811 (1994)

Genetic Algorithm for Synchronization Adam Roman Institute of Computer Science Jagiellonian University, Cracow, Poland [email protected]

Abstract. We present a novel approach to the synchronization problem. It is a well-known fact that a problem of finding minimal (or: the shortest) synchronizing word (MSW) for a given synchronizing automaton is NPcomplete. In this paper we present the genetic algorithm which tries, for a given automaton, to find possibly short word that synchronizes it. We use a modified version of a classical simple genetic algorithm (SGA).

1

Introduction

Synchronizing automata have many practical applications. They are used in robotics (for designing so-called part orienters) [1], bioinformatics (the reset problem) [2], network theory [3], theory of codes [4] etc. On the other hand, synchronizing theory is nowadays a field of the very intensive research, motivated ˇ mainly by the famous and still open Cern´ y Conjecture. It claims that (n − 1)2 is an upper bound for the length of minimal synchronizing word (MSW) in any ˇ n-state synchronizing automaton. This conjecture, stated in 1964 by Cern´ y [5], is the most longstanding open problem in automata theory. When trying to apply the synchronization theory in some practical issues, the main problem we have to deal with is to find the minimal (or as short as possible) synchronizing word in some automaton. This problem is known as NP-complete [6]. For automata with small number n of states the exponential algorithm works well, but when n grows, it becomes useless. Instead of it we can use one of the well-known polynomial algorithms, such like Eppstein algorithm, cycle algorithm or others [6,7]. Each of them works good for some class of automata, but in general they rarely find the optimal solutions. In this paper we present a genetic algorithm for solving the problem. According to our best knowledge, this is the first attempt to apply an evolutionary approach to the synchronization problem. Our approach is based on the model of simple genetic algorithm (SGA). The research on the abilities and limitations of the SGA (that is, what kinds of problems it can and cannot solve) has been heavily influenced by a theory of adaptation called the building block hypothesis [8,9,10]. It has become an object of a strong critique. The main reproach was that it lacks theoretical justification. Moreover some experimental results have been published that draw its veracity into question. The researchers tried to find some other models of evolutionary computations that would work better A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 684–695, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Genetic Algorithm for Synchronization

685

than SGA. New paradigms of evolutionary computations have arisen: evolutionary programming (with arbitrary chromosome structure), genetic programming, evolutionary strategies. In this paper we try to support somehow the idea lying behind the theory of SGA. The algorithm presented in Section 3 gives a promising result, mainly because the synchronizing problem nature fits well into SGA paradigm. In SGA chromosome population is, in fact, the population of solutions to the encoded version of the original problem. When the best solution is found, it must be decoded into the language of the original problem. Usually the encoding and decoding functions are not identities. In the synchronizing problem an automaton is given and we want to find the shortest word which synchronizes it. Notice that in case of binary alphabet the word itself is the solution and it represents the chromosome directly - no encoding/decoding function is needed. In other words, genotype equals phenotype here. Moreover, it seems that the building block hypothesis works in this case, because the algorithm converges to local optima. The paper is organized as follows: in Section 2 we introduce the basic notions referring to the synchronization theory and we formulate the synchronization problem. In Section 3 we present the genetic algorithm based on SGA paradigm, but with some modifications (mainly related to parameter adaptation issues). All genetic operations and heuristics used in GA are described there. Section 4 is devoted to the experiments and their results. Finally, in Section 5 we summarize our results and describe the future work in the field of evolutionary approach to synchronization problem.

2

Synchronizing Automata

Let A be a finite set. By A∗ we denote the free monoid over A. If we interpret A as an alphabet, then A∗ is the set of all finite words over A. For example, if A = {a, b}, then A∗ = {ε, a, b, aa, ab, ba, bb, aaa, aab, ...}, where ε is an empty word. The length of w ∈ A∗ is the number of its letters. We denote the length of w by |w| and we define |ε| = 0. By |w|a we denote the number of occurrences of a in w. An automaton is a triple A = (Q, A, δ), where Q is a finite set of states, A is a finite alphabet and δ : Q × A → Q is a transition function. It can be naturally extended on 2Q × A∗ → 2Q in the following way: δ(P, ε) = P , δ(P, aw) =  ∗ p∈P δ(δ(p, a), w), where p, q ∈ Q, P ⊆ Q, w ∈ A . Since now we assume that we deal only with full, deterministic and strongly connected automata, that is: (1) δ is a total function on Q × A, (2) ∀p, q ∈ Q ∃w ∈ A∗ : δ(p, w) = q. For the sake of simplicity, we will write p.a = q instead of δ(p, a) = q. Definition 1. Let A = (Q, A, δ) be an automaton. If there exists w ∈ A∗ such that |Q.w| = 1, we call w a synchronizing word for A. We also say that A is synchronizing. For a given A = (Q, A, δ) and w ∈ A∗ we define the deficiency of w as follows: df(w) = |Q| − |Q.w|. If w synchronizes A, then df(w) = |Q| − 1.

686

A. Roman

It is clear that if w synchronizes A, then each word of the form uwv (u, v ∈ A∗ ) also does it. Therefore a natural question arises: what is the shortest synchronizing word for A? Such a word will be called a minimal synchronizing word (MSW) for A. By m(A) we denote the length of the MSW for A. ˇ Conjecture 1 (Cerny, 1964). Let A be an n-state synchronizing automaton. Then m(A) ≤ (n − 1)2 . For many classes of automata the conjecture was shown to be true (see for ˇ example [1,11,12,13,14]), but in general it is still an open problem. Cern´ y showed that for each n there exists an n-state automaton with MSW of length (n − 1)2 . ˇ These are so-called Cern´ y automata and are denoted by Cn . Now we can formally define the synchronizing problem: Definition 2 (Synchronizing problem). Given A = (Q, A, δ), find w◦ = argmin {|w|}. w: |Q.w|=1

3

Genetic Algorithm

SGA transforms population of solutions in a way that imitates nature. The algorithm is described in Listing 1. We assume the reader to be familiar with basic notions and properties of SGA and we do not describe SGA here (see [8] for details). Throughout the paper the following notions will be used: N denotes the population size, t denotes the discrete time - in each time unit one population is processed (t = 0, 1, 2, ...). P t is a population in time t. By f we denote the fitness function and dti ∈ A∗ is the i-th chromosome in P t (i = 1, 2, ..., N ). Algorithm 1. Simple Genetic Algorithm 1: begin 2: t←0 3: initiate population P 0 4: evaluate P 0 5: while (not stop criterium) do 6: begin 7: T t ← selection in P t 8: Ot ← crossover and mutation in T t 9: evaluate Ot 10: P t+1 ← Ot 11: t←t+1 12: end 13: end

Let us now describe some important differences between SGA and our algorithm.

Genetic Algorithm for Synchronization

687

1. In synchronization problem each solution is a word over some alphabet A. As we mentioned earlier, we will understand that words are chromosomes and their letters represent genes. But these words can have different lengths. Therefore we assume that the chromosome length is not fixed. This will have some important consequences when defining crossover and mutation; 2. We use adaptation methods for changing mutation and crossover probability during the algorithm work. Adaptation is also used for modifying the probability distribution P(A) over an alphabet. This distribution is utilized in the initiation phase and also in the mutation; 3. We use elitist selection - two copies of the best chromosome from P t−1 pass into P t and the remaining N −2 are chosen using proportional selection based on the roulette wheel method. Here by ”best” we understand the shortest word among all words in P t−1 with the highest deficiency. In the next subsections we describe all details of our algorithm. All experiments will be performed for automata over binary alphabet, but in the theoretical parts of this paper we assume that A is arbitrary (that is, |A| ≥ 2). Initial Probability Distribution for Letters. The initial population P 0 is constructed using the heuristic on the distribution P(A). Let A = (Q, A, δ) be an automaton and let Ca = {P ⊂ Q : ∀p, q ∈ P ∃i ≥ 1 p.ai = q} = {P1 , P2 , ..., P|Ca | }. Ca is the set of all cycles in directed graph Ga = (Q, E), where (p, q) ∈ E ⇔ p.a = q. We define μ(a) = LCM(|P1 |, |P2 |, ..., |P|Ca | |) as the lowest common multiple of the lengths of all cycles over a in A. We also define ξ(a) = min{k : ∀l > k Q.al = Q.ak }. In other words, ξ(a) is the longestpath  (over a ∈ A) leading from some state p ∈ Q \ Ca to some state q ∈ Ca , assuming that no state appears twice or more on this path. If μ(a) is small, then there are more states lying on the paths leading to cycles, so they can be easily synchronize by ak for some k into Q.ak , such that |Q.ak | equals the number of cycles. When μ(a) is large, then more states are lying on cycles and usually it is harder to synchronize these states than in a previous case. Now we are ready to define the probability distribution for alphabet letters: ∀a ∈ A P(a) = 

ξ(a) + μ(a) . l∈A ξ(l) + μ(l)

(1)

Distribution (1) will be used for generating genes in initial population, as well as in the mutation operator. Chromosome Length in P 0 . The lengths of the words generated in the initial population are random according to a uniform distribution on {1, 2, ..., M }, where M is a fixed maximal length of chromosome. From [15] and [16,17] we know that for each n there exists an automaton Cn such that m(Cn ) = (n − 1)2 3 and that for each synchronizing A it is true that m(A) ≤ n 6−n , so necessarily 3 (n − 1)2 ≤ M ≤ n 6−n . From the other hand, ”Higgins [18] has shown that if Q is a set with n elements (where n is sufficiently large), then on average any product of 2n randomly chosen transformations of Q is a constant map. Being retold in

688

A. Roman

automata-theoretic terms, it implies that a randomly chosen automaton having n states and over a sufficiently large input alphabet tends to be synchronized, and, moreover, it is synchronized by any word of length 2n” [19]. Numerical computations confirm that the mean length of MSW tends to behave linear (or even logarithmic) in n (see Fig. 1). ˇ y conjecture is true at least for binary alphabet, We strongly believe that Cern´ therefore in all experiments M has been usually defined as a value a little greater than n2 . According to the results described above, a more theoretical study is needed on the probability distribution of MSWs lengths for a given n. We could, for example, use a normal distribution N (m, σ) with m = Θ(n), but we don’t know which σ would be the best choice. Nevertheless, we have decided to use a uniform distribution on {1, 2, ..., M }, because the algorithm works well even if the words in the initial population are much more longer than m(A). The use of a normal (or some other) distribution could increase the algorithm convergence, but, as we said, little is known about the parameters of such a distribution.

Fig. 1. Mean MSW length for a random n-state synchronizing automaton. Sample size = 1000 for each n = 5, 6, ..., 15. Linear regression: y = 0, 486x + 1, 654, R2 = 0, 985.

Probability Distribution Adaptation. When the algorithm works, the probability distribution for letters is modified. Let P t be the currently processed population and let P be the probability distribution for letters in step t − 1. If N

df(dti ) > N

i=1

N

i=1

df(dt−1 ) i , N

then we compute the empirical distribution for letters from P t by the formula N

Pemp (a) = i=1 N

|dti |a

i=1

|dti |

(2)

Genetic Algorithm for Synchronization

689

and we put P ← Pemp . The reason for implementing such an adaptation is simple: the optimal distribution should be equal to the distribution Pw in the MSW w, but this word is of course unknown. If the average deficiency in P t increases in relation to the average deficiency in P t−1 , it means that P t is ”on t average” better than P t−1 and it’s empirical distribution Pemp is more similar to t Pw than the current one. Therefore we make Pemp to be our new distribution P. Genetic Operators. Both mutation and crossover probabilities are defined by two values: pm and pm for mutation and pc and pc for crossover. At the beginning pm = pm , pc = pc and pm , pc remain unchanged during the algorithm work. We use an adaptive technique for pm and pc values: if, in step t, maxp∈P t f (p) ≤ maxp∈P t−1 f (p), we increase pm by 0.001 and pc by 0.01. In other case we put pm = pm and pc = pc . Experiments showed that this simple adaptation mechanism speeds up the algorithm convergence. Crossover. We use a modified version of one-point crossover, taking under consideration the variability of the chromosome length. Given two chromosomes dti = a1 a2 ...as and dtj = b1 b2 ...bt we pick two random numbers q, r, such that 1 ≤ q ≤ s and 1 ≤ r ≤ t. The crossover results with two new offsprings a1 a2 ...aq br+1 br+2 ...bt and b1 b2 ...br aq+1 aq+2 ...as , provided that q + (t − r) ≤ M and r + (s − q) ≤ M , where M is the maximal allowed chromosome length. Mutation. There are three types of mutation: M1 for each letter in a given word flip a coin. If it’s head, substitute the current letter a with another one. If |A| > 2 the new letter should be chosen according to the uniform distribution on A \ {a}; M2 insert a random subword in a random place of the given word; letters for the new subword are generated with the current probability distribution P; M3 delete a random subword from a given word. Mutation is realized as follows: Let u ∈ [0, 1] be a random number. If u ≤ pm flip a coin. If head, perform (M2) else perform (M3). At the end perform (M1) with probability pm for each letter. If mutation results with an empty word ε, replace it by a one-letter word. The letter is chosen randomly, according to the current probability distribution P. Fitness Function. In order to evaluate the chromosome, we have to take into consideration two values: |w| and df(w). The shorter word is and the greater deficiency it has, the better it is. Moreover, we want f to have the following two properties: (P1) if |Q.w| < |Q.v|, then f (w) > f (v); (P2) if |Q.w| = |Q.v| and |w| < |v|, then f (w) > f (v). After several series of experiments we have chosen the following fitness function: df4 (w) . f (w) =  4 |w|

(3)

Let w, v be two words such that df(w) > df(v). If |w| ≤ |v|, then clearly (P1) and (P2) holds. If |w| > |v|, (P1) and (P2) are almost always fulfilled,

690

A. Roman

because in practice, especially when n is large,  1 (1 + )4 > 4 |w| |v| . df(w)−1

|w| |v|

is usually close to 1 and then

Algorithm. In this section we give the formal algorithm description. It is shown in Listing 2. P denotes the current probability distribution for letters. Algorithm 2. SynchroGA 1: begin 2: INPUT: A = (Q, A, δ) 3: popSize← 40, pm ← 0.03, pm ← pm , pc ← 0.7, pc ← pc 4: compute P 5: t←0 6: initialize P0 using P 7: evaluate P0 8: while (t < mboxpopN umber) do 9: begin 10: Tt ← selection Pt //elitist + roulette wheel 11: Ot ← crossover and mutation (with P) on Tt // use pm and pc 12: evaluate Ot 13: if maxp∈P t f (p) ≤ maxp∈P t−1 f (p) 14: pm ← pm + 0.001, pc ← pc + 0.01   15: else p c m ← pm , p c ← p 1 16: if N p∈P t df(p) > N1 p∈P t−1 df(p) 17: compute Pemp in P t 18: P ← Pemp 19: Pt+1 ← Ot 20: t←t+1 21: end 22: end

4

Experiments and Results

In order to evaluate the quality of the SynchroGA algorithm three experiments were performed. Experiment 1. SynchroGA was launched for several automata, one hundred times for each of them. In each run i = 1, 2, ..., 100 algorithm processed 2000 generations and returned ci ∈ P 1999 , which is the shortest among all words in P 1999 with the highest deficiency. The results of this experiment are gathered in Table 1. Two first columns represent an automaton and the length of its MSW. Let m = maxi {df(ci )} and W = {ci : df(ci ) = m}. Columns 3-5 give some statistical information on the set W : the minimal, average and the maximal length of the words from W . Columns 6-8 give the same statistical information (but now for all words c1 , c2 , ..., c100 ) on the value of |Q.ci |. Column 9 shows a mean number of the first generation in which a word from W has been found. Column 10 describes the maximal allowed chromosome length.

Genetic Algorithm for Synchronization

691

Table 1. Results of the first experiment A m(A) A21 A41 A61 B21 B41 B61 C6 C11 C16 C21 C41 D7 D21 D41

20 40 60 20 40 60 25 100 225 400 1600 30 380 1560

Genetic algorithm |M SW | |Q.w| MSW max min mean max min mean max N ChrSize 20 20.51 23 1 1 1 466.47 500 40 41.85 46 1 1 1 643.86 2000 60 62.6 70 1 1 1 778.23 4000 20 20 20 1 1 1 248.76 500 40 40.12 41 1 1 1 757.16 2000 60 60.73 63 1 1 1 1123.97 4000 25 28.42 33 1 1 1 1336.44 200 117 139.4 168 1 1.06 2 1619.46 200 262 262 262 1 2.02 3 1572 300 282 391.9 493 2 2.59 4 1790.56 500 1562 1562 1562 3 6.09 9 1977 2000 30 31.57 38 1 1.14 2 1254.81 40 421 421 421 1 2 3 1682 500 1337 1548.57 1791 2 4.1 6 1757.43 2000

Automaton An = ({1, 2, ..., n}, {a, b}, δ) has the following transition function: for i < n i.a = i + 1; n.a = n; for all i i.b = i. It is clear that MSW length for An is an−1 and m(An ) = n − 1. Bn = ({1, 2, ..., n}, {a, b}, δ) is defined as follows: for even i, i.a = i − 1 and i.b = i; for odd i ≥ 3, i.a = i and n i.b = i − 1; 1.a = 1.b = 1. Minimal synchronizing word for Bn is (ba) 2 for n n−1 odd and a(ba) 2 for n even. Automata An and Bn are similar, but their initial probability distributions are different, so the experiment allows us to check if the ˇ probability adaptation mechanism works. Cn are n-state Cern´ y automata and 2 n−1 n−2 ) b. Automaton it is known that m(Cn ) = (n − 1) [15]. MSW here is (ba Dn (n odd) with Q = {0, 1, ..., n − 1} has the following transition function: i.a = i − 2(mod n) if i = 0, 1; i.a = i if 2 ≤ i ≤ n − 1; i.b = i − 1(mod n). It was proved [20] that m(Dn ) = (n − 1)(n − 2) and it is realized by the word w = (ab2k−1 )k−1 (ab2k−2 )k−1 a, where n = 2k + 1. Experiment 2. A thousand random 14-state synchronizing automata were generated. For each of them SynchroGA found a minimal synchronizing word. Fig. 2 shows the distribution of the number of the first generation t, in which the best word was found. A typical run of the algorithm is shown in Fig. 3. Characteristic slow growths and immediate decreases of |Q.w| are caused by the adaptive change of mutation and crossover probability. If, for a long period of time, no solution with higher deficiency is found, pm and pc grow. The algorithm then tends to behave more randomly, so the mean fitness decreases. When a new, better solution is found, pm and pc are set to their initial values and we can observe an immediate decrease of mean |Q.w| and increase of the mean fitness.

692

A. Roman

Fig. 2. For n = 10, 20, ..., 600 histogram shows the number of algorithm runs in which MSW was found in generation t, n − 10 ≤ t < n

Fig. 3. A typical run of SynchroGA

Genetic Algorithm for Synchronization

693

Experiment 3. In the previous experiment computations were done for automata with small number of states. This is because we had to compare the result of SynchroGA with the minimal synchronizing word for a given automaton. This required the use of an exponential algorithm, so the number n of states had to be small. In this experiment we operate on bigger automata. In this case computing MSW is not possible, so instead of MSW value we use a regression line from Fig. 1. For each n = 15, 16, ..., 100 a ten random n-state automata were generated. In Fig. 4 the mean value of the shortest synchronizing word found by SynchroGA is shown in comparison with the values obtained from the regression equation for x = n. We see that these values tend to behave as a linear function, but with a lower slope than the regression line y = 0.486x+1.654 from Fig. 1. Taking into account that a genetic algorithm usually does not find the best solution but rather a sub-optimal one, results shown in Fig. 4 reinforce our conviction that the mean MSW length for a random n-state synchronizing automaton is proportional to an, with a much smaller than 0.486.

Fig. 4. Mean value of the shortest synchronizing word found by SynchroGA (n = 15, ..., 100) and regression line y = 0.486x + 1.654 from Fig. 1

5

Conclusions and Future Work

Experiment 1 shows that SynchroGA works good, but for ”harder” automata ˇ (that is, with MSWs lengths quadratic in n, such like MSWs for Cern´ y automata), the convergence decreases when n grows. For random automata (experiment 2) our algorithm deals with the synchronization problem very well and converges quickly. This can be explained by the fact that the expected value of MSW in a random automaton is (probably) linear or even logarithmic in n, so these words are rather short: results for automata An and Bn (see Table 1) confirm that SynchroGA works very good if MSW is short. Therefore, if we

694

A. Roman

see that the algorithm has a problem with finding a word with a high deficiency, we can almost be sure that the automaton has a long MSW. We can improve the mean length of the synchronizing words found by SynchroGA. When it finds the best solution w, we can check if its length can be shortened. Let w = a1 a2 ...an . If there are i < j such that Q.w1 ...wi = Q.w1 ...wj it is clear that for v = a1 ...ai aj+1 ...an we have Q.w = Q.v, but |v| < |w| (notice that even if |Q.w| = 1, it does not imply that v will be the minimal synchronizing word, but only that it can be shorter than w). The optimizing step can be done not only at the end but, for example, after each k generations for each chromosome in the population. This, however, would highly increase the run time. Notice that in a few cases the algorithm failed to find a synchronizing word. In such situation we can combine the genetic algorithm with any of the heuristic algorithms for finding short synchronizing words (for example, an Eppstein one [6]) in a following way: when a word w is found by the genetic algorithm and |Q.w| > 1, then run Eppstein algorithm for Q.w. It will return a word v such that |Q.wv| = 1, so the result is a synchronizing word wv. In conclusion, we think that SynchroGA can be a useful tool in finding short synchronizing words. Future work should concentrate on tuning up the algorithm: finding the optimal mutation and crossover probability, dealing with another selection methods (for example a tournament selection method) and so on. As it was said before, a research on the relation between the automaton structure and it’s m(A) value should be done. This could be useful for choosing better initial probability distribution P. Algorithm can be found at www.ii.uj.edu.pl/∼roman/publications.html.

References ´ 1. Ananichev, D., Volkov, M.: Synchronizing monotonic automata. In: Esik, Z., F¨ ul¨ op, Z. (eds.) DLT 2003. LNCS, vol. 2710, pp. 111–121. Springer, Heidelberg (2003) 2. Benenson, Y., Adar, R., Paz-Elizur, T., Livneh, L., Shapiro, E.: DNA molecule provides a computing machine with both data and fuel. Proc. National Acad. Sci. USA 100, 2191–2196 (2003) 3. Kari, J.: Synchronization and stability of finite automata. JUCS 8(2), 270–277 (2002) 4. J¨ urgensen, H.: Synchronization. Information and Computation 206(9-10), 1033– 1044 (2008) ˇ 5. Cern´ y, J.: Pozn´ amka k. homog´ennym experimentom s konecnymi automatmi. Mat. fyz. cas SAV 14, 208–215 (1964) 6. Eppstein, D.: Reset sequences for monotonic automata. SIAM J. Comput. 19, 500– 510 (1990) 7. Roman, A.: Synchronizing finite automata with short reset words. Appl. Math. Comp. (in press, 2008), doi:10.1016/j.amc.2008.06.019 8. Goldberg, D.E.: Genetic Algorithms in Search, Optimization and Machine Learning. Addison-Wesley, Reading (1989) 9. Holland, J.H.: Adaptation in Natural and Artificial Systems. An Introductory Analysis with Applications to Biology, Control, and Artificial Intelligence. University of Michigan Press Edition (1992)

Genetic Algorithm for Synchronization

695

10. Mitchell, M.: An Introduction to Genetic Algorithms. MIT Press, Cambridge (1998) ˇ 11. Dubuc, L.: Les automates circulaires et la conjecture de Cern´ y. Inform. Theor. Appl. 32, 21–34 (1998) 12. Kari, J.: Synchronizing finite automata on eulerian digraphs. Theor. Comp. Sci. 295, 223–232 (2003) 13. Rystsov, I.: Reset words for commutative and solvable automata. Theor. Comp. Sci. 172, 273–279 (1997) ˇ 14. Trahtman, A.N.: The existence of synchronizing word and Cern´ y conjecture for some finite automata. In: Second Haifa Workshop on Graph Theory, Combinatorics and Algorithms, Haifa (2002) ˇ 15. Cern´ y, J., Pirick´ a, A., Rosenauerova, B.: On directable automata. Kybernetica 7, 289–298 (1971) 16. Klyachko, A.A., Rystsov, I., Spivak, M.A.: An extremal combinatorial problem associated with the bound on the length of a synchronizing word in an automaton. Kybernetika 2, 16–20 (1987) 17. Pin, J.E.: On two combinatorial problems arising from automata theory. Annals of Discrete Mathematics 17, 535–548 (1983) 18. Higgins, P.M.: The range order of a product of i transformations from a finite full transformation semigroup. Semigroup Forum 37, 31–36 (1988) 19. Volkov, M.: Personal communication (2008) 20. Ananichev, D., Volkov, M., Zaks, Y.: Synchronizing automata with a letter of deficiency 2. In: H. Ibarra, O., Dang, Z. (eds.) DLT 2006. LNCS, vol. 4036, pp. 433–442. Springer, Heidelberg (2006)

Constructing Infinite Words of Intermediate Arithmetical Complexity Paul V. Salimov Sobolev Institute of Mathematics, prosp. Koptyuga 4, 630090, Novosibirsk, Russia [email protected]

Abstract. Arithmetical complexity of an infinite word, defined by Avgustinovich, Fon-Der-Flaass and Frid in 2000, is the number of words of length n which occur in its arithmetical subsequences. We present a construction of infinite words whose arithmetical complexity function grows faster than any polynomial, but slower than any exponential. Also we give a rough upper bound for the arithmetical complexity of the Sierpi´ nski word.

1

Introduction

Let Σ be a finite alphabet, and x = x0 x1 · · · ∈ Σ IN0 be an infinite word on Σ with indices in IN0 = IN ∪ {0}. A factor or subword of x is a finite word that occurs as a block of successive letters in x, i.e., is equal to xk xk+1 . . . xk+n for some k and n, and if k = 0 such a subword is called prefix. The notation Fx is used for the set of subwords of x. The length of a finite word u is a number of letters in it and is denoted by |u|. A classical complexity measure of a sequence x on a finite alphabet is the subword complexity that is the function fx counting the number of its distinct subwords of the given length. A survey on subword complexity can be found at [1]. We consider another complexity measure that is the function ax which counts not only factors of a given word but all distinct words occurring in its arithmetical progressions. Namely, the arithmetical complexity function ax of n is the number of distinct words of the form xk xk+d . . . xk+(n−1)d for arbitrary initial positions k  0 and differences d  1. The set of such words is called the arithmetical closure of Fx and is denoted by Ax . The arithmetical complexity was introduced in 2000 by Avgustinovich, FonDer-Flaass and Frid [2] and has become one of the most well-explored modified complexity functions relative to the subword complexity. Characterizing the set of possible arithmetical complexity functions is a challenging problem and only partial results in this direction are known. Most of them concern words of polynomial arithmetical complexity. A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 696–701, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Constructing Infinite Words of Intermediate Arithmetical Complexity

697

It was shown in [3] how to construct words of intermediate subword complexity. In this paper we obtain the similar result for the arithmetical complexity. Namely, we present a construction of infinite words on the binary alphabet of c c arithmetical complexity that satisfies 2c1 n  ax (n)  c2 n4 2c3 n for some c < 1 and some c1 ,c2 ,c3 .

2

Definitions

Let Σ = Σs = {0, 1, . . . , s − 1} be a finite alphabet. The set of all finite words on Σ is denoted by Σ ∗ , the set of all non-empty finite words is denoted by Σ + and the set of all words of length n is denoted by Σ n . A morphism ϕ : Σ ∗ → Σ ∗ is a map that obeys the identity ϕ(xy) = ϕ(x)ϕ(y) for all words x, y ∈ Σ ∗ . A morphism is called m-uniform if all images of letters have the same length equal to m. An m-uniform morphism ϕ : Σ ∗ → Σ ∗ with m > 0 generates a mapping that maps an infinite word x = x0 x1 . . . to the word ϕ(x0 )ϕ(x1 ) . . . . We denote this mapping by the same letter ϕ. If a morphism ϕ is m-uniform with m  2 and the word ϕ(a) starts with a letter a for some a ∈ Σ, then there always exists an infinite word x satisfying x = ϕ(x) and it can be obtained as a limit limn→∞ ϕn (a). Such a word x is called a fixed point of the morphism ϕ. Example 1. The well-known Sierpi´ nski word s = 0101110101111 . . . is a fixed point of the 3-uniform morphism ϕS on Σ2 defined by ϕS (0) = 010 and ϕS (1) = 111. An m-uniform morphism ϕ : Σs∗ → Σs∗ is symmetric if the word ϕ(i) is a result of a symbol-by-symbol addition modulo s of ϕ(0) with ii . . . i for each i. It was shown in [4] that non-periodic fixed points of a symmetric morphism are of exponential arithmetical complexity. In [5] uniformly recurrent words of linear arithmetical complexity were studied, and some of them are fixed points of morphisms too. We will consider some subclass of m-uniform morphisms and will prove that the arithmetical complexity functions of their fixed points grow slower than any exponential. Then we will show how to obtain words of intermediate arithmetical complexity from fixed points of such morphisms. A word x is called universal if Fx = Σ ∗ . We will need some facts about mechanical words [6]. An upper mechanical word s = s0 s1 . . . is an infinite word that can be defined by si = (i + 1)α + ρ − iα + ρ for some real α ∈ [0, 1] and ρ, i.e., mechanical words are either periodic or Sturmian words. Let the function χ(n) be the number of distinct words which are factors of mechanical words. It was proved (see Theorem 2.2.36 in [6]) that χ(n) = 1 + ni=1 (n + 1 − i)φ(i) where φ is Euler’s totient function, so χ(n)  cχ n3 .

698

3

P.V. Salimov

The Construction

Let us consider any morphism ϕ satisfying the following conditions: ϕ is an m-uniform Σ2∗ → Σ2∗ morphism ; ϕ(0) starts with 0 ; ϕ(0) contains exactly t occurrences of 0, where 1 < t < m ; ϕ(1) = 1m .

(1)

The upper bound for the arithmetical complexity function of its fixed point grows slower than any exponential. Namely, we will prove the following statement. Theorem 1. If an infinite word x is a fixed point of a morphism ϕ satisfying conditions (1), then its arithmetical complexity function obeys the inequality 2

ax (n)  4m2 nχ(mn)2t

nlogm t

.

The main idea of the proof is that words of the arithmetical closure of x do not differ “very much” from those of the set Fx , due to conditions (1). More precisely, we will show that every word of the arithmetical closure of x can be obtained from some subword of x of length mn by some character deletion of a special kind and replacing some symbols 0 with 1. And since the number of occurrences of 0 in subwords of x grows slowly, we get a non-exponential upper bound for the arithmetical complexity function. Let us define μ0 as the function counting occurrences of a symbol 0 in a finite word. Lemma 1. If v is a subword of a fixed point of a morphism ϕ satisfying conditions (1), then μ0 (v)  tlogm |v| . Proof. Let k = logm |v|. The word x is a fixed point of ϕ, so, by the definition, x = ϕk (x) = ϕk (x0 )ϕk (x1 ) . . . where |ϕk (xi )| = mk  |v|. Hence, v is a subword of some word of the form ϕk (xj )ϕk (xj+1 ). Conditions (1) in particular contain k ϕk (1) = 1m thus the maximum of μ0 (v) is achieved when v is a subword of ϕk (00). In this case μ0 (v)  μ0 (ϕk (0)). From conditions (1) we have μ0 (ϕk (0)) =   tk . There is some linear upper bound for the subword complexity function of a fixed point of an m-uniform morphism. Lemma 2. The subword complexity of a fixed point x of an m-uniform morphism on the binary alphabet satisfies the inequality fx (n)  4mn . This lemma is a particular case of Theorem 10.3.1 from the book [7].

Constructing Infinite Words of Intermediate Arithmetical Complexity

699

Proof (of Theorem 1). Let us consider a word u = xk xk+d . . . xk+(n−1)d of the arithmetical closure of x with mc  d < mc+1 . The word x is a fixed point of ϕ so, by the definition, x = ϕc (x) = ϕc (x0 )ϕc (x1 ) . . . , where |ϕc (xi )| = mc (here ϕ0 is the identity map). Thus u is in the arithmetical closure of some word w = ϕc (v) of length equal to mc+1 n where the word v is a subword of length equal to mn of x. More precisely, u = wk0 wk0 +d . . . wk0 +(n−1)d , where k0 = k modulo mc . Let us divide the set {0, 1, . . . , mc+1 n − 1} into blocks Bi = {imc, imc + 1, . . . , imc + mc − 1} where 0  i < mn. Now we can define the characteristic word θ = θ0 θ1 . . . θmn−1 of the progression k0 + jd as follows: θi = 1 if and only if there exists some j such that k0 + jd ∈ Bi , otherwise θi = 0. The word θ is a factor of some mechanical word. More precisely, if s is a word defined by si = (i + 1)mc /d − k0 /d − imc /d − k0 /d, then θ is a prefix of s. Let us prove it. If si = 1, then there exists such j that (i + 1)mc /d − k0 /d > j and imc /d − k0 /d  j; in other words, (i + 1)mc > k0 + dj  imc . So, we have mn blocks; each of them contains at most 1 integer belonging to the progression k0 + jd. Let us consider a mapping M that maps each number i of a block to a symbol of w at a position within the block Bi . And let us define the word u = u (M, θ) for such a mapping M and θ by ui = M (j) where j is a position of the i’s occurrence of 1 in θ. Obviously, if M is such that M (i) = wk0 +jd when k0 + jd ∈ Bi for some j, then u (M, θ) = u. Thus ax (n) is less then or equal to the product of a number of possible θs, which is not greater than χ(mn), and a number of possible M s, which we will estimate next. It follows from conditions (1) that Bi contains a position of 0 in w only if vi = 0. Therefore, from Lemma 1 we have that at most μ0 (v)  tlogm mn blocks contain positions of 0 in w. Hence, the number of possible M s for current logm mn v is not greater than 2t and the number of all possible M s is not greater logm mn than 2t fx (mn). Thus, using Lemma 2 we have logm mn

ax (n)  fx (mn)χ(mn)2t 2

= 4m nχ(mn)2

t(mn)logm t

1+logm mn

 4m2 nχ(mn)2t 2

= 4m nχ(mn)2

t2 nlogm t

.

=  

Corollary 1. The arithmetical complexity of the Sierpi´ nski word satisfies the inequality log3 2 . asp (n)  36nχ(3n)24n Suppose that in an infinite word x from Theorem 1 some 0 were replaced with 1. Obviously, this will not increase the number of possible concerned mappings M . Namely, the following statement is true. Proposition 1. If an infinite word x is obtained from a fixed point of a morphism ϕ satisfying conditions (1) by replacing 0 with 1 at some positions, then its arithmetical complexity function obeys the inequality

700

P.V. Salimov 2

ax (n)  4m2 nχ(mn)2t

nlogm t

.

This proposition and Lemma 1 allow us to construct words of intermediate complexity. Indeed, fixed points of morphisms satisfying conditions (1) are recurrent, which mean that they have infinitely many occurrences of each prefix. And each prefix p contains t logm |p| symbols 0. So if we replace 0 with 1 on proper positions logm n in x then we obtain a word with subword complexity not less than 2t . We are to formalize the replacing method. Let x and y be infinite or finite words on Σ2 . We denote by R0 (x, y) a word obtained from x by replacing the i’s occurrence of 0 in x with a symbol yi . Example 2. Let the word s = 0101110101 . . . be the Sierpi´ nski word from Example 1 and y = y0 y1 . . . be an infinite word, then R0 (s, y) = y0 1y1 111y2 1y3 . . . . Proposition 2. If an infinite word x is a fixed point of a morphism ϕ satisfying conditions (1) and y is a universal word, then the arithmetical complexity function of the word z = R0 (x, y) obeys the inequality az (n)  2

nlogm t t

.

Proof. Obviously, az (n)  fz (n). The word x is a fixed point of ϕ so, by the definition, x = ϕk (x) = ϕk (x0 )ϕk (x1 ) . . . for each k, and μ0 (ϕk (xi )) is either tk or 0. Hence, the set of subwords of the word z contains all words of the form R0 (ϕk (0), yitk yitk +1 . . . y(i+1)tk −1 ) for arbitrary i. k Each word s ∈ Σ t can be found at position jtk for some j in the word y. This k follows from the fact that y is universal and thus contains a subword (s0)t −1 s. So we have that the set of subwords of the word R0 (x, y) contains at least logm n distinct words of length n. Hence 2t logm n

az (n)  2t

logm n−1

 2t

−1

= 2t

nlogm t

.

 

The definition of R0 (x, y) fits the conditions of Proposition 1. So the main result of this paper can be formulated as follows Proposition 3. For arbitrary t, m ∈ IN, where 1 < t < m, an infinite word x on Σ2 with arithmetical complexity satisfying 2

nlogm t t

2

 ax (n)  4m2 nχ(mn)2t

nlogm t

can be constructed.

Acknowledgements The author is grateful to Anna Frid and Sergey Avgustinovich.

Constructing Infinite Words of Intermediate Arithmetical Complexity

701

References 1. Ferenczi, S.: Complexity of sequences and dynamical systems. Discrete Math. 206(1), 145–154 (1999) 2. Avgustinovich, S.V., Fon-Der-Flaass, D.G., Frid, A.E.: Arithmetical complexity of infinite words. In: Ito, M., Imaoka, T. (eds.) Words, Languages and Combinatorics III, pp. 51–62. World Scientific Publishing, Singapore (2003) 3. Cassaigne, J.: Constructing infinite words of intermediate complexity. In: Ito, M., Toyama, M. (eds.) DLT 2002. LNCS, vol. 2450, pp. 173–184. Springer, Heidelberg (2003) 4. Frid, A.E.: Arithmetical complexity of symmetric D0L words. Theoret. Comput. Sci. 306(1), 535–542 (2003) 5. Frid, A.E.: Sequences of linear arithmetical complexity. Theoret. Comput. Sci. 339, 68–87 (2005) 6. Lothaire, M.: Algebraic Combinatorics on Words. Cambridge University Press, Cambridge (2002) 7. Allouche, J.P., Shallit, J.: Automatic Sequences. Theory, Applications, Generalizations. Cambridge University Press, Cambridge (2003)

From Gene Trees to Species Trees through a Supertree Approach Celine Scornavacca1,2, , Vincent Berry2, and Vincent Ranwez1 1

2

Institut des Sciences de l’Evolution (ISEM, UMR 5554 CNRS), Universit´e Montpellier II, Place E. Bataillon - CC 064 - 34095 Laboratoire d’Informatique, de Robotique et de Micro´electronique de Montpellier (LIRMM,UMR 5506, CNRS), Universit´e Montpellier II 161, rue Ada, 34392 Montpellier Cedex 5, France {scornava,vberry}@lirmm.fr, [email protected]

Abstract. Gene trees are leaf-labeled trees inferred from molecular sequences. Due to duplication events arising in genome evolution, gene trees usually have multiple copies of some labels, i.e. species. Inferring a species tree from a set of multi-labeled gene trees (MUL trees) is a wellknown problem in computational biology. We propose a novel approach to tackle this problem, mainly to transform a collection of MUL trees into a collection of evolutionary trees, each containing single copies of labels. To that aim, we provide several algorithmic building stones and describe how they fit within a general species tree inference process. Most algorithms have a linear-time complexity, except for an FPT algorithm proposed for a problem that we show to be intractable.

1

Introduction

An evolutionary tree (or phylogeny), is a tree displaying the evolutionary history of a set of sequences or organisms. A gene tree is an evolutionary tree built by analyzing a gene family, i.e. homologous molecular sequences appearing in the genome of different organisms. Gene trees are primarily used to estimate species trees, i.e. trees displaying the evolutionary relationships among studied species. Unfortunately, most gene trees can significantly differ from the species tree for methodological or biological reasons, such as long branch attraction, lateral gene transfers, deep gene coalescence and, principally, gene duplications and losses [1]. For this reason, species trees are usually estimated from a large number of gene trees. Inferring a species tree from gene trees is mostly done in a two-step approach. First, a micro-evolutionary model that takes into account events affecting individual sites is used to infer the gene trees. The species tree is then inferred on the basis of a macro-evolutionary model, i.e. minimizing the number of transfer, duplication and loss events [2,3,4,5,6]. To produce more biologically meaningful trees, unified models have been proposed in which the micro and 

Corresponding author.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 702–714, 2009. c Springer-Verlag Berlin Heidelberg 2009 

From Gene Trees to Species Trees through a Supertree Approach

703

macro-evolutionary dimensions are entangled [7,8,9]. However, it is difficult to determine how to incorporate events occurring on different spatial and temporal scales, as well as belonging to neutral and non-neutral processes, in a single model [9]. Lately, a hybrid approach has been proposed, where a first draft of a species tree is inferred with a micro-evolutionary model, the most uncertain parts of which are then corrected according to a macro-evolutionary model [9]. In this paper, we propose instead to take advantage of the very large number of gene trees present in recent phylogenomic projects to avoid entering into the detail of all possible macro-evolutionary scenarios (e.g. is a parsimony approach always justified? Should only the most parsimonious scenario be retained?). We propose to extract the non-ambiguous part of the topological information contained in the gene trees, i.e. that resulting from speciation events as opposed to duplication events, and then apply a traditional supertree method letting the weight of evidence decide in favor of one candidate species tree [10,11,12]. This approach is only possible when the number of gene trees is very large, and indeed this is now the case in projects such as the HOMOLENS database (http://pbil.univ-lyon1.fr/databases/homolens.php), storing several thousands of gene trees. In the release 04 of this database, 51% of gene families have paralogous sequences, i.e. sequences where duplications and losses have actually taken place. Currently, these gene families are discarded when inferring a supertree of the concerned species. Disentangling information derived from speciation events from that resulting from duplication events would thus provide more information for species tree inference. Supertree methods combine source trees whose leaves are labeled with individual species into a larger species tree. The source trees are single-labeled, i.e. each species labels at most one leaf. Note that, by definition, the inferred supertree is also single-labeled. In contrast, gene trees are usually multi-labeled, i.e. a single species can label more than one leaf, since duplication events resulted in the presence of several copies of the genes in the species genomes. The task we therefore have to solve is to extract the largest amount of unambiguous topological information from the multi-labeled gene trees under the form of single-labeled trees. This paper presents a number of results in this direction, that all play a role in the general scheme that is fully described below. The rest of the paper details these results, though in a different order for the sake of dependancies between definitions. First of all, we propose to separately preprocess MUL trees in order to remove their redundant parts with respect to speciation events. For this purpose, we extend the tree isomorphism algorithm of [13] making it applicable to MUL trees while preserving a linear running time (section 5). This algorithm is then applied to the pairs of subtrees hanging from duplication nodes in MUL trees. This preprocess lowers the number of duplication nodes in gene trees. We also give in passing a linear time algorithm to identify duplication nodes in MUL trees (section 4). For the gene trees that still have duplication nodes, we define a set R of triplets (binary rooted trees on three leaves [14,12]) containing the topological information of a MUL tree that can be thought of as being unambiguously

704

C. Scornavacca, V. Berry, and V. Ranwez

related to speciation events. We show that this set of triplets can be computed in O(|R|) time (section 2). When this set is compatible, the MUL tree contributes a coherent topological signal to build the species tree. In such a case, we can replace the MUL tree with a single-labeled tree representing its associated set of triplets by using the BUILD algorithm [14] (section 3). When a MUL tree is not auto-coherent, we propose to extract a maximum subtree that is both autocoherent and free of duplication events. Surprisingly, this optimization problem can be solved in linear time (section 6). When extracting largest single-labeled subtrees from MUL trees it is possible to obtain an incompatible collection, when a compatible collection could have been obtained by choosing subtrees of MUL trees in a coordinated way. However, solving this problem is computationally harder, as we show by providing an NP-completeness proof (section 7).

2

Preliminaries

In this paper we focus on rooted binary multi-labeled (MUL) trees. Let M be a MUL tree and v a vertex of M . We denote by s(v) and s’(v) the two sons of v and by sons(v) the set {s(v),s’(v)}. We define by subtree(v) the subtree with v as root and by L(v) the multiset of labels of subtree(v). We denote by L(M ) the multiset L(root(M )). Definition 1. A node v of M is called an observed duplication node (odn) if the intersection of L(s(v)) and L(s (v)) is not empty. Note that, for an odn v, L(v) will always contain some label more than once. We denote by D(M ) the set of odn. A label l ∈ L(M ) is a repeated label for M iff the label l occurs more than once in L(M ). We say that f is a repeated leaf for M iff L(f ) is a repeated label. For every three leaves we can have three different rooted tree binary shapes, called triplets. We denote by AB|C the rooted tree that connects the pair of taxa (A, B) to C via the root. We denote by R(M ) the set of triplets of a (single/multi)labeled evolutionary tree M i.e. R(M ) = {ab|c s.t. there exist three leaf nodes x, y, z ∈ M : L(x) = a, L(y) = b, L(z) = c and lca(x, y) = (lca(x, z) = lca(y, z))}1. Definition 2. Let M be a MUL tree. We define by Rwd (M ) (R(M ) without duplications) the set of triplets ab|c of M s.t. there exist three leaf nodes x, y, z ∈ M : L(x) = a, L(y) = b, L(z) = c and lca(x, y) ∈ / D(M ), lca(x, y, z) ∈ / D(M ), lca(x, y) = (lca(x, z) =lca(y, z)). For example, for the MUL tree in Fig. 1, Rwd (M )={ac|b, ac|d,ab|d,bc|d,ac|o,ab|o, ad|o,bc|o,cd|o,bd|o,ab|c}. Hence, not all the triplets of R(M ) are kept. This is due to the fact that, once a duplication event occurred in a gene’s history, the two copies of the gene evolved independently. The history of each copy is influenced by the species history but, considering them simultaneously may produce information unrelated to the species evolution. Therefore, it is more appropriate to discard the triplets mixing the histories of distinct copies of a gene. 1

lca(x, y) denotes the least common ancestor of nodes x and y, i.e. the lowest node in the tree that has both x and y as descendants.

From Gene Trees to Species Trees through a Supertree Approach

705

Fig. 1. An example of MUL tree with one odn indicated by a black square

Rwd (M ) has an O(n3 ) size and can be computed in O(n3 ) time. Indeed, once the lca of all pairs of nodes in M are computed in O(n) time (see [15,16]), checking for three leaf nodes x, y, z of M if they satisfy Definition 2 can be done in O(1) time, thus in O(n3 ) for all triplets of leaves in M .

3

Auto-coherency of a MUL Tree

Let M be a multi-labeled gene tree. Since M contains several copies of the same gene, we can wonder whether the evolutionary signal of each copy is coherent or not. Definition 3. A MUL tree M is said to be auto-coherent if there exists a single-labeled tree T such that Rwd (M ) ⊆ R(T ). In the case of an auto-coherent MUL tree, we know that we can find a tree T containing all the information in Rwd (M ), i.e. the information of M that is considered reliable. To find such a tree, we use the AncestralBuild algorithm of [17]. For a set of triplets Rwd (M ), this algorithm indicates in O(|Rwd (M )|·log2 n) time whether there exists a tree T s.t. Rwd (M ) ⊆ R(T ) and returns T in case of a positive answer. At present, it is not clear whether an implicit representation of Rwd (M ) using only O(n) triplets, as that reported in [18] to encode an binary tree, could be used here. Indeed, the presence of multiple occurrences of labels might lead to obtain a small compatible sets of triplets, while the whole set Rwd (M ) would be incompatible.

4

Computing D(M ) in Linear Time

The easiest way to compute D(M ) is checking for each node v if the sets L(s(v)) and L(s (v)) have at least one label in common; in the case of a positive answer, v is inserted in D(M ). The complexity of this approach is O(n2 ), since it requires computing O(n) intersections of two lists of O(n) elements. The algorithm 1 uses the lca to find the set of odn D(M ) and requires only linear time. To demonstrate the correctness of algorithm 1, we need to determine some relationships between the lca and the odn. Lemma 1. A node is an odn if and only if it is the lca of at least two repeated leaves m and p.

706

C. Scornavacca, V. Berry, and V. Ranwez

Proof. Indeed, from the definition 1, v is an odn iff L(s(v)) ∩ L(s’(v)) = ∅. Therefore, ∃m ∈ subtree(s(v)) and ∃p ∈ subtree(s (v)): L(m) = L(p). Thus v is a common ancestor of the two leaves m and p with the same label. Now, m and p belong to two different subtrees having v as father (m ∈ subtree(s(v)) and p ∈ subtree(s (v))), hence v is their lowest common ancestor in M . Reciprocally, if v is the lca of two leaves m and p with the same label, this means that L(s(v)) ∩ L(s’(v)) = ∅, then v is an odn according to definition 1.  According to Lemma 1, we can search for the lca of any two leaves m and p with the same label. To determine the lca between multiple pairs of nodes, one can use an algorithm in [15] which preprocesses a data structure in O(n) time, where n is the number of nodes and returns the lca of any two specific nodes from the data structure in O(1). We still have O(n2) of these couples, and even constant time for each gives an O(n2) total complexity. However, since there are only O(n) odn, checking the lca of any pair of leaves computes the same lca several times. A smarter approach is used in algorithm 1: first of all, the subtrees of M are ordered from the left to the right in an arbitrary way. Then, each repeated leaf, starting from the left of the tree and moving to the right, is tagged with the repeated label followed by its occurrence number. Then, for each repeated label e, the lca of any two successive occurrences of e, ei and ei+1 is inserted in D(M ). This leads to a linear time complexity. Indeed, we have O(n) of these couples since each leaf of M is involved in at most two pairs (ei , ei+1 ). Algorithm 1. CompDuplicationNodes(r) Data: A MUL tree M . Result: A set of odn D(M ). Order M in an arbitrary way. In this order, tag each duplicated leaf with the repeated label followed by its occurrence number. Compute the lca for each couple of leaves. D(M ) ← ∅; foreach (repeated label e) do foreach ({ej , ej+1 }) do D(M ) ← lca(ej , ej+1 ); return D(M );

The correctness of algorithm 1 is justified by Lemma 2 showing that algorithm 1 retrieves all the odn of M . Lemma 2. Let M be a MUL tree. For each odn v, ∃ two successive occurrences of a label e denoted by ei and ei+1 s.t. v = lca(ei , ei+1 ). Proof. Given an odn v, there exists at least one label e present in both subtrees s(v) and s (v). We denote by A the set of leaves ai s.t. ai ∈ subtree(s(v)) and L(ai ) = e and by B the set of leaves bj s.t. bj ∈ subtree(s (v)) and L(bj ) = e. If we take the last element of B (b|B| ) and the first one of A (a1 ), we know that v is their lca. Additionally, due to the way we tagged M, we know that there is no other occurrence of the label e between b|B| and a1 . Indeed, if there was another leaf x labeled with e, it would be either in s(v) (and then x = a1 ) or

From Gene Trees to Species Trees through a Supertree Approach

707

in s (v) (and then x = b|B| ). Then b|B| and a1 are two successive occurrences of the same label and their lca is the node v. 

5

Isomorphic Subtrees

Definition 4. Two rooted trees T1 , T2 are isomorphic (denoted by T1 =T2 ) iff there exists a one-to-one mapping from the nodes of T1 onto the nodes of T2 preserving leaf labels and descendancy. We are interested in testing if, for each odn v, the two subtrees s(v) and s (v) are isomorphic or not. In the positive, we can prune one of the two isomorphic subtrees without losing any information contained in Rwd and eliminate the odn v, as in the example of Fig. 2. For detecting isomorphism of multi-labelled trees, we propose Algorithm 2, an extension of the Check-isomorphism-orfind-conflict algorithm [19]. Indeed, the latter does not deal with MUL trees. Alternatively, we could have proposed an appropriate variant of the tree isomorphism algorithm detailed in [20]. However, such an algorithm would likely have been less space efficient than the one we present here due to a number of string sorting steps using a number of queues and lists to ensure linear running time. A node that has only two leaves as children is called cherry. In the case of single-labeled trees we have the following lemma: Lemma 3. [13] Let T1 , T2 be two isomorphic trees and let c1 be a cherry in T1 . Then, there is a cherry c2 ∈ T2 s.t. L(c1 ) = L(c2 ). In the case of M U L trees, we can have several copies of the same cherry. We call a multiple cherry the list of cherries on the same two labels. For a multiple cherry mc, we note |mc| the number of occurrences of the cherry in its tree. Lemma 4. Let M1 , M2 be two isomorphic MUL trees and let mc1 be a multiple cherry in M1 . Then, there is a multiple cherry mc2 ∈ M2 s.t. L(mc1 ) = L(mc2 ) and |mc1 | = |mc2 |. The proof is inspired from that of Lemma 3 in [13] and left to the reader. 5.1

Outline of the Algorithm

First of all, we find all the multiple cherries for the MUL trees M1 and M2 . We store them in the list Lmc using a simple linked list. Additionally, we use a

n

n ∈ D(M )

a b c a b cx x y

n ∉ D(M )

a b c

x x y

Fig. 2. An example of MUL tree where the sons of the duplication node are isomorphic

708

C. Scornavacca, V. Berry, and V. Ranwez

Algorithm 2. CheckIsomorphismMULTree(M1,M2 ) Data: Two MUL tree M1 and M2 . Result: TRUE if M1 and M2 are isomorphic, FALSE otherwise. Let Lmc be the list of multiple cherries in M1 and M2 . Let H be the hashtable where each mc ∈ Lmc is a key. To each H(mc), we associates two lists O2 (mc) and O1 (mc), resp. of the occurrences of mc in M1 and M2 ; while (Lmc = ∅) do mc ← the first multiple cherry in Lmc ; delete mc form Lmc ; if (O2 (mc) = O1 (mc) ) then Turn all cherries in O2 (mc) and O1 (mc) into leaves to which a same new label is assigned; add the new multiple cherries in Lmc and H; else return FALSE; return TRUE;

hashtable H where each mc ∈ Lmc is a key. H associates to each multiple cherry mc two linked lists, O1 (mc) and O2 (mc), storing pointers to nodes of M1 and M2 respectively that correspond to the occurrences of mc. The multiple cherries of a MUL tree are then examined in a bottom-up process. Given a multiple cherry mc in Lmc we check if the size of O1 (mc) is the same as that of O2 (mc). If this is not the case, we have found a multiple cherry for which we do not have the same number of occurrences in M1 and M2 . In this instance, M1 and M2 are not isomorphic (Lemma 4) and the algorithm returns FALSE. Otherwise we turn all the cherries in O1 (mc) and O2 (mc) into leaves to which a same new label, different from all other labels in M1 and M2 , is assigned. This modification of M1 and M2 can turn the fathers of some cherries in O1 (mc) and O2 (mc) into new cherries. Then Lmc is updated and the processing of cherries in M1 is iterated until both MUL trees are reduced to a single leaf with the same label if M1 and M2 are isomorphic, or a FALSE statement is returned. Theorem 1. Let M1 and M2 be two rooted MUL trees with L(M1 ) = L(M2 ) of cardinality n. In time O(n), algorithm 3 returns TRUE if M1 and M2 are isomorphic, FALSE otherwise. Proof. This algorithm is an extension of the Check-isomorphism-or-findconflict algorithm [19] applicable to MUL trees. We show here that we can keep a linear time execution, using supplementary data structures. A simple depth-first search of trees M1 and M2 initializes Lmc and H in O(n) time. At each iteration of the algorithm, choosing a multiple cherry mc to process is done in O(1) by removing the first element mc of Lmc . H then provides in O(1) the lists O1 (mc) and O2 (mc) of its occurrences in the trees. Checking that these lists have the same number of elements is proportional to the number of nodes they contain, hence costs O(n) amortized time, as each node is only once in such a list, and the list is processed once during the whole algorithm. Replacing all occurrences of mc by a new label is done in O(n) amortized time, since each replacement is a local operation replacing

From Gene Trees to Species Trees through a Supertree Approach

709

three nodes by one in a tree and at most O(n) such replacements can take place in a tree to reduce it down to a single node (the algorithm stops when this situation is reached). Reducing a cherry can create a new occurrence omc of a cherry mc . Checking in O(1) time if mc is a key in H allows to know whether occurrences of mc have already been encountered or not. In the positive, we simply add omc to the beginning of the list O1 (mc) (if omc ∈ M1 ) or O2 (mc) (if omc ∈ M2 ), requiring O(1) time. In the negative, we add mc to the beginning of Lmc , create a new entry in H for mc , and initialize the associated lists O1 (mc) and O2 (mc) so that one contains omc and the other is the empty list. Again, this requires only O(1) time. Thus, performing all operations required by the algorithm globally costs O(n) time.  Apply algorithm 2 to each subtree(s(v)) and subtree(s (v)) of each odn of a MUL tree M in a bottom-up approach requires O(dn) time, where d is the number of duplication nodes in M .

6

Computing a Largest Duplication-Free Subtree of a MUL Tree

If a MUL tree is not auto-coherent, identifying duplication nodes allows for the discrimination of leaves representing orthologous and paralogous sequences. Since only orthologous sequence history reflects the species history, a natural question is to determine the most informative sequence set for a given gene. As long as the gene tree contains odn, it will also contain leaves representing paralogous sequences. Yet, if for each node v ∈ D(M ) of M we choose to keep either s(v) or s (v), we obtain a pruned single-labeled tree containing only apparent orthologous sequences (observed paralogous have been removed by pruning nodes). Note that the so obtained single-labeled tree is auto-coherent by definition. Definition 5. Let M be a MUL tree. We say that T is obtained by (duplication) pruning M iff T is obtained from M choosing for each odn v either s(v) or s (v). We denote this operation by the symbol . One can wonder, for a non auto-coherent MUL tree M , what is the most informative single-labeled tree T s.t. T  M . We define this problem as the M IP T (Most Informative Pruned Tree) problem. To evaluate the informativeness of a tree we can use either the number of triplets of T (see [21,22,11]) that, for binary trees, depends only on the number of leaves, or the CIC criterion (see [23,12]). The CIC of a not fully resolved and incomplete2 tree T with |L(T )| leaves among the n possible is a function of both the number nR (T, n) of fully resolved trees T  on L(T ) such that R(T ) ⊆ R(T  ) and the number nR (n) of fully resolved trees on n leaves. More precisely,   CIC(T, n) = − log nR (T, n)/nR (n) 2

A tree is called incomplete when it misses some taxa.

710

C. Scornavacca, V. Berry, and V. Ranwez

Algorithm 3. pruning(v,M ,D(M )) Data: A node v, a MUL tree M , and a set of odn D(M ). Result: The most informative MUL tree M  s.t. subtree(v)M   subtree(v)M . foreach (m ∈ sons(v)) do pruning(m,M ,D(M )); if (v ∈ D(M )) then if (|L(s(v))| > |L(s (v))|) then v ← s(v); else v ← s (v); D(M ) ← D(M ) − {v}; return M ;

In the case of binary trees, nR (T, n) depends only on the number of source taxa missing in T since T does not contain multifurcations. Thus, dealing with binary trees, maximizing the information of a tree (i.e. maximizing the number of triplets or minimizing the CIC value) consists in finding the tree with the largest number of leaves. A natural approach for the MIPT problem for binary MUL trees is an algorithm that, after having computed D(M ), uses the bottomup algorithm 3, with v =root(M ), to keep the most informative subtree between subtree(s(m)) and subtree(s (m)), for each odn m. Theorem 2. Let M a MUL tree on a set of leaves of cardinality n. In time O(n), pruning(M,root(M ),D(M )) returns the most informative tree T s.t. T  M . Proof. First of all, it’s obvious that pruning(M,root(M ),D(M )) returns a tree. Indeed, if for each odn v only one node between s(v) and s (v) is kept, at the end of the bottom-up procedure one copy of each duplicated leaf is present in the modified M . Now, we have to show that the resulting tree is the most informative tree s.t. T  M , i.e. the tree with as many leaves as possible. For an odn v that is the ancestor of other duplication nodes, the choices made for s(v) do not influence the choices for s (v) since for each duplication node we can keep only one of the two subtrees, the most populous one. Thus we can search for the best set of choices left/right for s(v) and s (v) independently and then choose the most populous pruned subtree between s(v) and s (v). Iterating recursively this reasoning, we demonstrate that the tree obtained by Algorithm 3 is the most informative tree T s.t. T  M . The computation of the set of odn D(M ) takes linear time. The subroutine pruning(M, root(M), D(M )) requires a tree walk, thus the time complexity of Algorithm 3 is O(n). 

7

The Compatibility Issue of Single-labeled Subtrees Obtained from MUL Trees

We can also ask if it is possible, given a collection of MUL tree M, to discriminate leaves representing orthologous and paralogous sequences in a gene tree using the information contained in the other gene trees to obtain a compatible forest T , i.e. a forest for which there exists a tree T s.t. ∪Ti ∈T R(Ti ) ⊆ R(T ). We denote this problem by EPCF, Existence of a Pruned and Compatible Forest. Unfortunately, the EPCF problem is NP-complete.

From Gene Trees to Species Trees through a Supertree Approach

711

   Instance : A set of leaves X and a collection M={M1 , · · · Mk }   of MUL trees on X.  EPCF   Question : ∃ a set S of choices left/right, S : M → T ,   with T ={T1 , · · · Tk } s.t. Ti  Mi and T is compatible?  Theorem 3. The EPCF problem is NP-complete. Proof. We start by proving that EPCF is in NP, i.e. checking if a set S of choices left/right is a solution for the instance I = (M, X) can be done in polynomial time. First of all, for each MUL tree Mj ∈ M, we place the choices left/right on Mj , i.e. we discard the subtrees not chosen, obtaining a forest of trees T . We check then the compatibility of T with the Aho graph[14]. Constructing this graph can be done in polynomial time. Given that EPCF is in NP, we use a reduction of 3-SAT to EPCF to demonstrate that it is NP-complete.    Instance : A boolean expression C=(C1 ∧ C2 ∧ · · · ∧ Cn ) on a   finite set L={l1, l2 , · · · , lm } of variables with Cj =  3-SAT   (a ∨ b ∨ c) where {a, b, c} ∈ {l1 , l2 , · · · , lm , l1 , l2 · · · , lm }   Question : ∃ a truth assignment for L that satisfies all C in C ?  j We need to show that every instance of 3-SAT can be transformed into an instance of EPCF; then we will show that given an instance I = (C, L) of 3-SAT, I is a positive instance, i.e. an instance for which a solution exists, iff the corresponding instance for EPCF is positive. Given an instance I = (C, L) of 3-SAT, we build an instance I  = (M, X) of EPCF associating to each li in L the binary tree3 T (li ) = (((xi , yi ), zi ), d) and to li the binary tree T (l  i ) = (((zi , yi ), xi ), d) (see Fig. 3 for an example). The set of subtrees T (a) | a ∈ {l1 , l2 , · · · , lm , l1 , l2 , · · · , lm } is denoted by TL . Then, for each clause Cj = (a ∨ b ∨ c) in C, a binary MUL tree Mj is built, formed by three subtrees ((T (a), T (b)), T (c)). Note that Mj has exactly two duplication nodes due to the presence of d in T (a), T (b) and T (c), so that any left/right choice of Mj will reduce it to either T (a), T (b) or T (c). In Fig. 4 an example of a MUL tree built from aclause. In this way weobtain a forest of m MUL trees M on the leaf set X = i=1 {xi , yi , zi } ∪ {d} , i.e. an instance of the EPCF problem. Clearly M can be built in polynomial time. We now need to show that a positive instance of 3-SAT gives a positive instance of EPCF through the previous transformation. Having a positive instance for 3-SAT implies that for each Cj ∈ C with Cj = (a ∨ b ∨ c), at least one of the 3

T (li ) is expressed in the Newick format.

712

C. Scornavacca, V. Berry, and V. Ranwez

T(li)= xi

T(li)= yi

zi

zi

d

yi

xi

d

Fig. 3. Binary trees on four leaves associated to li and to li

xi yi zi d xi yi zi d xi yi _zi d

T(li)

T(lj)

T(lk)

Fig. 4. MUL tree built from the clause {li ∨lj ∨lk }. Odn are indicated by black squares

three literals is TRUE. Without loss of generality, let us suppose that a is TRUE. Then in the MUL tree Mj corresponding to Cj we set the choice left/right so that only the subtree T (a) is kept. We then obtain a forest T that is a subset of TL . We need to prove that T is compatible. Let T˜ (a) denote the tree T (a)|(L(T (a)) − {d})4 and T˜ the forest composed by all trees {T˜(a)|T (a) ∈ T }. Then, we can build a tree Ts = (T˜1 , T˜2 , · · · , T˜|T˜ | , d). Since li cannot have the value TRUE and FALSE at the same time, we have either T (li ) or T (li ) in T . The tree Ts is therefore a single-labeled tree. Moreover,  by construction Ts |(L(T (a)) is identical to T (a), for all T (a) in T ensuring that Ti ∈T R(Ti ) ⊆ R(Ts ). Thus T is compatible. Now, the only thing left to prove is that a positive instance of EPCF gives a positive instance of 3-SAT. The repetition of the taxon d in each subtree makes the two nodes connecting the subtrees in each Mj be odn. Thus a left/right choice set S reduces each Mj in M into a tree T (a) ∈ TL , providing the forest T . Setting the value of a to TRUE ensures that the clause Cj corresponding to Mj is TRUE. This can be done simultaneously for all clauses ∈ C since the forest compatibility implies that there is no contradiction among the trees in T , all the more so direct contradictions. Then, either T (li ) or T (li ) is in T . This ensures us that  either li or li is assigned to TRUE, but not both. Note that the problem to find the most informative forest T = {T1 , · · · Tk } s.t. Ti  Mi and T is compatible, denoted by MIPCF (Most Informative Pruned and Compatible Forest) is FPT. Indeed, analyzing all possible scenarios of choices left/right is FPT on the total number of duplication nodes in M. 4

Given a tree T and a label set S, we denote by T |S the restriction of T to the set S.

From Gene Trees to Species Trees through a Supertree Approach

8

713

Conclusions

In this paper we presented several algorithms to transform multi-labeled evolutionary trees into single-labeled ones so that they can be used by all existent supertree methods. In the future we plan to go further and extend the algorithm find-refinement-or-confict in [19] applicable to MUL trees and to work on a more sophisticated FPT algorithm for the MIPCF problem. This work was funded by the ANR-08-EMER-011 project.

References 1. Cotton, J., Page, R.: Rates and patterns of gene duplication and loss in the human genome. Proceedings of Royal Soceity of London 272, 277–283 (2005) 2. Ma, B., Li, M., Zhang, L.: From gene trees to species trees. SIAM J. Comput. 30, 729–752 (2000) 3. Hallett, M.T., Lagergren, J.: New algorithms for the duplication-loss model. In: RECOMB 2000, Fourth Annual International Conference on Computational Molecular Biology, pp. 138–146 (2000) 4. Chen, K., Durand, D., Farach-Colton, M.: Notung: a program for dating gene duplications and optimizing gene family trees. J. Comput. Biol. 7, 429–444 (2000) 5. Vernot, B., Stolzer, M., Goldman, A., Durand, D.: Reconciliation with non-binary species trees. J. Comput. Biol. 15(8), 981–1006 (2008) 6. Chauve, C., Doyon, J.P., El-Mabrouk, N.: Gene family evolution by duplication, speciation, and loss. J. Comput. Biol. 15(8), 1043–1062 (2008) 7. Goodman, M., Czelusniak, J., Moore, G.W., Romero-Herrera, A.E., Matsuda, G.: Fitting the Gene Lineage into its Species Lineage, a Parsimony Strategy Illustrated by Cladograms Constructed from Globin Sequences. Systematic Zoology 28(2), 132–163 (1979) 8. Arvestad, L., Berglund, A., Lagergren, J., Sennblad, B.: Bayesian gene/species tree reconciliation and orthology analysis using MCMC. Bioinformatics 19(suppl. 1), 7–15 (2003) 9. Durand, D., Halld–rsson, B., Vernot, B.: A hybrid micro-macroevolutionary approach to gene tree reconstruction. J. Comput. Biol. 13, 320–335 (2006) 10. Baum, B.R., Ragan, M.A.: The MRP method. In: Bininda-Emonds, O. (ed.) Phylogenetic supertrees: combining information to reveal the Tree of Life, pp. 17–34. Kluwer, Dordrecht (2004) 11. Page, R.D.M.: Modified mincut supertrees. In: Guig´ o, R., Gusfield, D. (eds.) WABI 2002. LNCS, vol. 2452, pp. 537–552. Springer, Heidelberg (2002) 12. Scornavacca, C., Berry, V., Lefort, V., Douzery, E.J.P., Ranwez, V.: Physic ist: cleaning source trees to infer more informative supertrees. BMC Bioinformatics 9(8), 413 (2008) 13. Gusfield, D.: Efficient algorithms for inferring evolutionary trees. Networks 21, 12–28 (1991) 14. Aho, A.V., Sagiv, Y., Szymanski, T.G., Ullman, J.D.: Inferring a tree from lowest common ancestors with an application to the optimization of relational expressions. SIAM J. Comp. 10(3), 405–421 (1981) 15. Harel, D., Tarjan, R.E.: Fast algorithms for finding nearest common ancestors. SIAM J. Comput. 13(2), 338–355 (1984)

714

C. Scornavacca, V. Berry, and V. Ranwez

16. Bender, M.A., Farach-Colton, M.: The lca problem revisited. In: Gonnet, G.H., Viola, A. (eds.) LATIN 2000. LNCS, vol. 1776, pp. 88–94. Springer, Heidelberg (2000) 17. Berry, V., Semple, C.: Fast computation of supertrees for compatible phylogenies with nested taxa. Syst. Biol. 55, 270–288 (2006) 18. Henzinger, M., King, V., Warnow, T.: Constructing a tree from homeomorphic subtrees, with applications to computational evolutionary biology. Algorithmica 24, 1–13 (1999) 19. Berry, V., Nicolas, F.: Improved parameterized complexity of the maximum agreement subtree and maximum compatible tree problems. IEEE/ACM Trans. Comput. Biol. Bioinformatics 3(3), 289–302 (2006) 20. Aho, A., Hopcroft, J., Ullman, J.: The Design and Analysis of Computer Algorithms. Addison-Wesley Longman Publishing Co., Inc., Boston (1974) 21. Ranwez, V., Berry, V., Criscuolo, A., Fabre, P., Guillemot, S., Scornavacca, C., Douzery, E.: PhySIC: a veto supertree method with desirable properties. Syst. Biol. 56, 798–817 (2007) 22. Semple, C., Steel, M.: A supertree method for rooted trees. Discrete Appl. Math. 105, 147–158 (2000) 23. Thorley, J., Wilkinson, M., Charleston, M.: The information content of consensus trees. In: Rizzi, A., Vichi, M., Bock, H.H. (eds.) Advances in Data Science and Classification. Studies in Classification, Data Analysis, and Knowledge Organization, pp. 91–98 (1998)

A Kleene Theorem for Forest Languages Lutz Straßburger ´ INRIA Saclay, ˆIle-de-France, Equipe-projet Parsifal ´ Ecole Polytechnique, LIX, Rue de Saclay, 91128 Palaiseau Cedex, France http://www.lix.polytechnique.fr/~lutz

Abstract. This paper proposes an alternative approach to the standard notion of rational (or regular) expression for tree languages. The main difference is that in the new notion we have only one concatenation operation and only one star-operation, instead of many different ones. This is achieved by considering forests instead of trees over a ranked alphabet, or, algebraicly speaking, by considering cartesian categories instead of term-algebras. The main result is that in the free cartesian category the rational languages and the recognizable languages coincide. For the construction of the rational expression for a recognizable language it is not necessary to extend the alphabet. We only use operations that can be defined with the algebraic structure provided by cartesian categories.

1

Introduction

Kleene’s theorem on the coincidence of the rational and the recognizable languages in a free monoid [1] is considered to be one of the cornerstones of theoretical computer science. Although it does not hold in every monoid [2], it has been generalized in several directions, e.g., [3,4,5]. Thatcher and Wright presented in [6] a similar result for tree languages. In recent years, recognizable tree languages have received increased attention because they form a foundation for XML schemas for expressing semi-structured data (e.g., [7,8,9]). In this paper I will only consider ranked trees and tuples of ranked trees, which I call forests to distinguish them from hedges [10] which are sequences of unranked trees [9]. The recognizable tree languages are defined by means of finite-state tree automata (fsta), which are a generalization of ordinary finite state automata (fsa) over words. While an fsa works on an alphabet A, an fsta works on a ranked alphabet Σ, i.e., every symbol in Σ is equipped with a rank, which is a natural number. The language recognized by an fsta is a subset of the set TΣ of all finite trees over Σ. The running example for this paper is the ranked alphabet Σ = {σ, γ, α}, where σ has rank 2, γ has rank 1, and α has rank 0. Let us define an fsta A with two states p and f , where f is a final state. Observe that (contrary to fsa on words) there are no initial states. Usually the behaviour of an fsta is represented as set of rules of a term rewriting system [11]. In the example, let the behaviour of A be described by the rules α→p

,

α→f

,

γ(p) → p ,

σ(p, f ) → f

.

A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 715–727, 2009. c Springer-Verlag Berlin Heidelberg 2009 

716

L. Straßburger

σ

@

γ

σ

@.

.. .

γ

γ

.. .

α

γ

γ

α

.. .

..

@

α

σ

@

α

γ

···

γ

···

γ

γ

@ @

α α

γ

···

γ

@

γ α Fig. 1. Left: The form of the trees in language L.

··

σ

 

σ

·

σ

α

Right: Depicted as forests.

The tree language L accepted by this automaton contains the tree α and all trees of the shape σ(γ . . . γα, σ(γ . . . γα, σ(. . . , σ(γ . . . γα, α) . . .))), which is more vivid if drawn as a tree as on the left of Fig. 1, where the number of γ’s in each chain and the number of σ’s can be any natural number (including zero). In order to find for this recognizable tree language a rational expression in the same sense as for recognizable word languages, we encounter the problem that there is no straightforward concatenation operation for trees. The concatenation of two words is simply their juxtaposition. But what is the concatenation of two trees? The approach taken in [6] is to paste one tree into some leaves of the other tree. In order to decide into which leaves of the first tree the second tree has to be plugged in, we have to name those leaves. In a tree over Σ, the leaves are labeled by the 0-ary symbols of Σ. Hence, for every 0-ary symbol of Σ, there is another concatenation operation. In order to obtain a rational expression for every recognizable tree language, it is necessary to extend Σ by additional 0-ary symbols. The rational expression for the language in our example is L = {α} ∪ ({σ(p, f )} ·p {γ(p)}∗p ·p {α})∗f ·f {α}

.

(1)

Observe that there are two additional symbols p and f with rank 0 that are not elements of Σ. This means that although the language L is a subset of TΣ , the sets {σ(p, f )} and {σ(p, f )} ·p {γ(p)}∗p , that occur in in (1), are not subsets of TΣ but subsets of TΣ∪{p,f } . We see two different concatenation operations, ·p and ·f , in (1), because there are two states in the corresponding automaton. It has been shown in [6], that for every recognizable tree language there exists such a rational expression, and that every tree language that can be represented by a rational expression is indeed recognizable. There are three points that one might find disturbing:

A Kleene Theorem for Forest Languages

     

α

@ @σ

   

   

@ @σ

  A


AA σ



 

@ @σ

   

α

A

@ @σ


AA σ



717

 

Fig. 2. The three forests s, t and r

(i) The language for formalizing the rational expressions is not predefined by Σ. For a given recognizable tree language L ⊆ TΣ , the number of different concatenation operations that occur in the rational expression for L is determined by the automaton that recognizes L. (In rational expressions for word languages we have only one concatenation operation.) (ii) The tree languages that are obtained by evaluating a subexpression of a rational expression for a language L ⊆ TΣ are usually not subsets of TΣ . (In the case of word languages, a subexpression of a rational expression for a language L ⊆ A∗ always represents a subset of A∗ .) (iii) The set TΣ of all trees over Σ forms the free Σ-algebra generated by the empty set. The tree concatenation operations have no correspondence in the Σ-algebra structure. (The set A∗ of all words over A forms the free monoid generated by A, and the word concatenation operation is the multiplication in the monoid.) As a consequence, the notion of rational (tree) language cannot easily be generalized to any Σ-algebra, as it has been done very successfully for rational languages in any monoid [2,3,4,5]. These three problems can be entirely avoided by a remarkable simple generalization: instead of concatenating trees, we concatenate tuples of trees, i.e., forests. The set of all forests over a ranked alphabet Σ will be denoted by Σ  . Algebraicly speaking, we generalize the notion of monoid not to a Σ-algebra but to a cartesian category, and Σ  is the free cartesian category generated by Σ. The usual free monoid of words can be seen as the special case in which all symbols in Σ have rank 1. One can visualize a forest as a box with holes on one side and plugs on the other. As example, Figure 2 shows three forests (for the same Σ as above). If we call them s, t and r, respectively, then s contains two trees and t and r contain each one tree. The leaves either contain a symbol of Σ with rank 0 or are connected to a hole of the box. The concatenation operation, which is the composition of arrows in the category, becomes now a plugging together of two forests with a matching number of plugs and holes. In our example, s and t can be plugged together and the result is r. With this approach, the many tree concatenation operations are reduced to a single forest concatenation operation. Note that this category has been around since the work by Lawvere on algebraic theories [12]. It has also been extensively studied in the context of

718

L. Straßburger

⎛ ⎜

L=

α

 ⎜ ⎜  ⎜

⎜ ⎝

α

   ·  γ

× α

 

⎞

 ⎟





⎟  L ⎟ ⎟ ·  LL ⎟ ⎠  σ

 

 





· 

σ

 

Fig. 3. The rational expression in for the language L

iteration theories [13], in which the regular forests have been characterized in various ways [14]. But the structure is different from preclones [15], which have another concatenation operation (see also Remark 2.2 in [15]). Our category is also a special case of a magmoid [16]. However, it seems that the structure of cartesian category has not yet been used to define the notion of rational expression in order to provide a Kleene-theorem (but see [17] for related work on unranked trees). The notion of recognizability presented in this paper is the same as the one by ´ Thatcher and Wright [6] or the one by Esik and Weil [15] (modulo the cosmetic difference that we consider forests instead of trees). The novelty is the new notion of rational expression, whose definition is closer to the rational languages in a monoid [2]. The only operations that are allowed are the componentwise union , the cartesian product ×, the concatenation ·, and the concatenation closure  , which is the generalization of the Kleene star ∗ for words. Although it is straightforward to translate the many concatenation and star-operations of [6] for trees into the corresponding forest operations presented in this paper, the converse translation is not so immediate. Nonetheless, it follows from [6] and our work, that the two notions coincide for tree languages. Thus, this paper provides yet another characterization of the recognizable (or regular) tree languages. For giving an example, the right-hand side of Fig. 1 shows how the language L can be depicted as forest language. The new rational expression is depicted in Fig. 3. Observe that there is only one concatenation operation and that every subexpression represents a subset of Σ  . Note that the operations used in a rational expression are available in any cartesian category (a category with a terminal object and all finite products). This means that the notions of recognizability and rationality defined in this paper are available in all cartesian categories, where the two notions do in general not coincide. Related to this work is the general notion of substitution (e.g., [18]). However, the set of substitutions forms a monoid and the composition of substitutions is the multiplication in that monoid. Imposing the notions of recognizability and rationality on substitutions would mean to use the well-known notions of recognizability and rationality in a monoid [2], whereas the purpose of this paper is to capture the notion of recognizability for trees. For this it is necessary to add to each substitution also the information about which variables occur in the domain and in the codomain; and this in turn leads to the notion of forest. All the technical details of this paper are available in [19].

A Kleene Theorem for Forest Languages

2

719

Forests

Forests are tuples of trees (or terms) over a ranked alphabet. In other words, they are the arrows in the free cartesian category generated by the alphabet, and the forest concatenation is the usual term substitution, which is the arrow composition in that category [12]. In order to make the paper self-contained, the definitions are given if full (without using category theory). Definition 1. A ranked alphabet Σ is a finite set of symbols together with a function rank : Σ → IN, which assigns to every symbol σ ∈ Σ its rank. For a given k ∈ IN, let Σk = {σ ∈ Σ | rank (σ) = k}. Example 1. For the example from the introduction we have Σ = Σ0 ∪ Σ1 ∪ Σ2 with Σ0 = {α}, Σ1 = {γ} and Σ2 = {σ}. Definition 2. Let Σ be a ranked alphabet. For every n, m ≥ 0, the set Σ  [n, m] of all (n, m)-forests over Σ is the smallest set such that the set Σ  [n, 0] = { n } is a singleton, for every i ∈ {1, . . . , n} (with n ≥ 1), there is a forest πin ∈ Σ  [n, 1], for every k ≥ 0 and t ∈ Σ  [n, k] and σ ∈ Σk , there is a forest tσ ∈ Σ  [n, 1], if m ≥ 2 and t1 , . . . , tm ∈ Σ  [n, 1], then t1 , . . . , tm ∈ Σ  [n, m].  The elements of the set Σ  = n,m∈IN Σ  [n, m] are called forests over Σ. (i) (ii) (iii) (iv)

Example 2. Let Σ be as above. Then s = π13 ,  3 α σ, π23 is a (3, 2)-forest and t = π22 , π22 σ, π12 σ is a (2, 1)-forest. Both are depicted in Fig. 2. Notation 1. By some abuse of notation, we can see Σk as subset of Σ  [k, 1], by identifying σ ∈ Σk with π1k , . . . , πkk σ ∈ Σ  [k, 1]. Definition 3. For a given ranked alphabet Σ, the forest concatenation ; is inductively defined as follows. (i) For every n, m ∈ IN and t ∈ Σ  [n, m], let t;  m =  n , (ii) for every n, m ∈ IN (with m ≥ 1), every t1 , . . . , tm ∈ Σ  [n, 1], and every i ∈ {1, . . . , m}, let t1 , . . . , tm ; πim = ti , (iii) for every n, m, k ∈ IN, every s ∈ Σ  [n, m], every t ∈ Σ  [m, k], and every σ ∈ Σk , let s; (tσ) = (s; t)σ, (iv) for every n, m, k ∈ IN (with k ≥ 2), every s ∈ Σ  [n, m], and every t1 , . . . , tk ∈ Σ  [m, 1], let s; t1 , . . . , tk = s; t1 , . . . , s; tk . Example 3. The concatenation of s and t above is s; t = π23 , π23 σ, π13 ,  3 α σ σ ∈ Σ  [3, 1], which is the forest r shown in Fig. 2. One can easily show that the forest concatenation is associative and that for every m . n, m ∈ IN and s ∈ Σ  [n, m] we have that π1n , . . . , πnn ; s = s = s; π1m , . . . , πm  Hence, we have a category (that we also denote by Σ ) whose objects are the non-negative integers, the terminal object is 0, the cartesian product is given by the usual addition, and the πin are the projections. I will write εn for π1n , . . . , πnn ∈ Σ  [n, n] if n ≥ 1 (resembling the empty word ε in the free monoid) and ε0 for  0 ∈ Σ  [0, 0].

720

3

L. Straßburger

Recognizable Forest Languages

One can define recognizability either via automata or via the inverse image of a morphism into a finite structure. In our case this would be a cartesian category with countably many objects but with finite hom-sets. Usually there is a straightforward translation between such a morphism and a deterministic finitestate automaton. Our case is no different in that respect. But many costructions on automata, for example concatenation, require the non-deterministic model. Thus, we define the recognizable forest languages via (non-deterministic) finitestate forest automata (fsfa) which accept those languages. Morally, an fsfa is the same as a finite-state tree automaton (fsta), see e.g. [11], but technically, there is a subtle difference: fsfa have initial as well as final states, whereas fsta do only have final states. On the other hand, usual finite-state automata (fsa) over words do also have initial as well as final states. Thus, forest automata regain a symmetry which was lost for tree automata. In the definitions that follow, we will stay as close as possible to the theory of fsa for word languages [20]. The main difference is that there is no longer a single state transition relation (or state transition function), but a family of such relations (or functions), one for each rank that occurs in the ranked alphabet Σ. Definition 4. Let n, m ∈ IN. A (nondeterministic) finite-state (n, m) forest automaton ((n, m)-fsfa) is a tuple A = Q, Σ, I, F, E , where Q is a finite set of states, Σ is a ranked alphabet, I = I1 × . . . × In (with I1 , . . . , In ⊆ Q) is the set of initial state tuples, F = F1 × . . . × Fm (with F1 , . . . , Fm ⊆ Q) is the set of final state tuples, and E = {Ek | k ≥ 0}, where Ek ⊆ Qk × Σk × Q (for every k ≥ 0) is the set of state transition relations. Since Σ is finite, the relation Ek is empty for almost all k ∈ IN. In order to define the language accepted by an fsfa A, it is necessary to extend the relations Ek from symbols in Σ to forests in Σ  . For this let us define for every A ⊆ (P(Q))k × Σ  [k, l] × Ql (where P(Q) denotes the powk, l ≥ 0 a relation Ek,l A erset of Q). Informally speaking, we have (Q1 , . . . , Qk , t, p1 , . . . , pl ) ∈ Ek,l iff  the forest t ∈ Σ [k, l] can cause a transformation from the states in Q1 , . . . , Qk to the state tuple p1 , . . . , pl . The formal definition is given inductively on the structure of the elements of Σ  [k, l]. A (i) For every k ≥ 0 and Q1 , . . . , Qk ⊆ Q, we have (Q1 , . . . , Qk ,  k ,  ) ∈ Ek,0 , where  k ∈ Σ  [k, 0] is the unique (k, 0)-forest (cf. Def. 2) and  ∈ Q0 is the empty tuple of states, (ii) for all k ≥ 0 and Q1 , . . . , Qk ⊆ Q and i ∈ {1, . . . , k} and q ∈ Qi , we have A , (Q1 , . . . , Qk , πik , q) ∈ Ek,1  (iii) for all k, k ≥ 0 and t ∈ Σ  [k, k  ] and σ ∈ Σk and Q1 , . . . , Qk ⊆ Q and A p1 , . . . , pk , q ∈ Q, if (Q1 , . . . , Qk , t, p1 , . . . , pk ) ∈ Ek,k  and A (p1 , . . . , pk , σ, q) ∈ Ek , then (Q1 , . . . , Qk , tσ, q) ∈ Ek,1 ,

A Kleene Theorem for Forest Languages

721

(iv) for all k ≥ 0 and l ≥ 2 and Q1 , . . . , Qk ⊆ Q and p1 , . . . , pl ∈ Q and A t1 , . . . , tl ∈ Σ  [k, 1], if (Q1 , . . . , Qk , ti , pi ) ∈ Ek,1 , for every i ∈ {1, . . . , l}, A then (Q1 , . . . , Qk , t1 , . . . , tl , p1 , . . . , pl ) ∈ Ek,l . Definition 5. Let n, m ∈ IN and A = Q, Σ, I, F, E be an (n, m)-fsfa. Then L(A) = { t ∈ Σ  [n, m] | ∃p1 , . . . , pm ∈ F . (I1 , . . . , In , t, p1 , . . . , pm ) ∈ A En,m } is the language accepted (or recognized) by A. Example 4. Let Σ be as before. Define the (0, 1)-fsfa A = Q, Σ, I, F, E by Q = {p, f } and I = ∅ and F = {f } and E0 = {( , α, p), ( , α, f )} ,

E1 = {(p , γ, p)} ,

E2 = {(p, f , σ, f )} .

Then L(A) is the set of all forests with the shape shown on the right of Fig. 1. Definition 6. A (n, m)-forest language L ⊆ Σ  [n, m] is called recognizable if there is an (n, m)-fsfa A = Q, Σ, I, F, E with L(A) = L. The set of all recognizable (n, m)-forest languages over Σ is denoted by Rec(Σ  )[n, m]. Further, Rec(Σ  )[n, m] Rec(Σ  ) = n,m∈IN

is the set of all recognizable forest languages over Σ. The concept of fsta is usually introduced by means of term rewriting systems [11,21]. It should be obvious that such an fsta is the same as a (0, 1)-fsfa (Def. 4): a (0, 1)-fsfa has no initial states, the set of final state tuples is reduced to a set of final states and the relations Ek contain exactly the same information as the rules of the term rewriting system of a tree automaton, since there is not much difference between the tuple (q1 , . . . , qk , σ, q) ∈ Ek and the rewrite rule σ(q1 , . . . , qk ) → q (with σ ∈ Σk ). This means that for a given Σ, the set Rec(Σ  )[0, 1] is isomorphic to the set of recognizable tree languages over Σ. Sometimes the discussion is casted in terms of tree languages over a ranked alphabet Σ and a finite set of variables X. In [11], the set of recognizable tree languages over Σ and X is denoted by Rec(Σ, X). If n = |X| is the number of symbols in X, then Rec(Σ, X) is isomorphic to Rec(Σ  )[n, 1]. Definition 7. An (n, m)-fsfa A = Q, Σ, I, F, E is called deterministic if |I| = 1 (i.e., there is only one input state tuple), and for every k ≥ 0, every σ ∈ Σk and every q1 , . . . , qk , p1 , p2 ∈ Q, if (q1 , . . . , qk , σ, p1 ) ∈ Ek and (q1 , . . . , qk , σ, p2 ) ∈ Ek , then p1 = p2 (i.e., the next state is uniquely determined). An (n, m)-fsfa A = Q, Σ, I, F, E is called totally defined if for every k ≥ 0, every σ ∈ Σk and q1 , . . . , qk ∈ Q, there is a p ∈ Q such that (q1 , . . . , qk , σ, p) ∈ Ek . For a deterministic and totally defined (n, m)-fsfa A, the relations Ek ⊆ Qk × Σk × Q are graphs of functions δk : Qk × Σk → Q. In this case the definitions A can be simplified by the use of functions δk,l : Qk × Σ  [k, l] → Ql instead of the A k  l A relations Ek,l ⊆ (P(Q)) × Σ [k, l]× Q . The functions δk,l define a functor from

722

L. Straßburger

the free cartesian category Σ  to a cartesian category with finite hom-sets. More A explicitely, for a determinisic (0, 1)-fsfa, the function δ0,1 : Σ  [0, 1] → Q is a Σalgebra homomorphism whose inverse image of F ⊆ Q is L(A) ⊆ Σ  [0, 1], as it is in the definition of deterministic tree automata [11]. We have the following proposition, whose proof uses the well-known power set construction. Proposition 1. Let n, m ∈ IN and A be an (n, m)-fsfa. Then there exists a deterministic and totally defined (n, m)-fsfa A such that L(A ) = L(A). A could be replaced by the much simpler In the view of this, the definition of En,m construction in the deterministic automaton. However, as in the case of automata over words, the construction in the proof of the Kleene theorem requires nondeterministic automata and a properly defined state transition relation, which is the reason for not using rewriting rules.

4

Closure Properties of Recognizable Forest Languages

As mentioned before, the set Rec(Σ  )[n, 1] ⊆ P(Σ  [n, 1]) of recognizable (n, 1)forest languages over Σ is isomorphic to the set Rec(Σ, X) ⊆ P(TΣ (X)), where |X| = n, of recognizable tree languages [11]. Hence, Rec(Σ  )[n, 1] is closed under the boolean operators intersection, union, and complement. Proposition 2. Let Σ be given and n ∈ IN. If L1 , L2 ∈ Rec(Σ  )[n, 1], then  LC 1 = Σ [n, 1] \ L1 as well as L1 ∪ L2 and L1 \ L2 are recognizable. Proposition 3. Let Σ be a ranked alphabet and n, m ∈ IN. If L1 , L2 ∈ Rec(Σ  )[n, m], then L1 ∩ L2 ∈ Rec(Σ  )[n, m]. It is important to notice, that the set Rec(Σ  )[n, m] is in general not closed under union. However, the recognizable languages are closed under cartesian product. With this as a base, we can define another operation  which will take the place of the union. Definition 8. If L1 ⊆ Σ  [n, m1 ] and L2 ⊆ Σ  [n, m2 ], then L1 × L2 = { t1 , . . . , tm1 +m2 ∈ Σ  [n, m1 + m2 ] | t1 , . . . , tm1 ∈ L1 and tm1 +1 , . . . , tm1 +m2 ∈ L2 } is the cartesian product of L1 and L2 . Proposition 4. Let Σ be a ranked alphabet and n, m ∈ IN. Further, let L ⊆ Σ  [n, m]. Then L ∈ Rec(Σ  )[n, m] iff there are L1 , . . . , Lm ∈ Rec(Σ  )[n, 1], such that L = L1 × . . . × Lm . Note that this implies that Rec(Σ  )[n, m] = Rec(Σ  )[n, 1]m . Definition 9. Let Σ be a ranked alphabet, let n, m, k ∈ IN, and let L1 ⊆ Σ  [n, m] and L2 ⊆ Σ  [m, k]. Then L1 ; L2 = {t1 ; t2 | t1 ∈ L1 , t2 ∈ L2 } is the naive concatenation of L1 and L2 .

A Kleene Theorem for Forest Languages

723

In the case that L2 is a singleton, say L2 = {ν}, I will write L1 ; ν instead of L1 ; {ν}, for notational convenience. Similarly, ν; L2 stands for {ν}; L2 . Definition 10. Let L, L ⊆ Σ  [n, m]. Then m m L  L = (L; π1m ∪ L ; π1m ) × . . . × (L; πm ∪ L ; πm )

is the componentwise union of L and L . Similarly, for a family {Li | i ∈ I} of languages with Li ⊆ Σ  [n, m] for all i ∈ I, define  

m m Li = Li ; π1 × . . . × Li ; πm . i∈I

i∈I

i∈I

Proposition 5. Let Σ be a ranked alphabet, and n, m ∈ IN. If L, L ∈ Rec(Σ  )[n, m], then L  L ∈ Rec(Σ  )[n, m]. Definition 11. Let Σ be a ranked alphabet and n, m, k ∈ IN. Further, let L ⊆ Σ  [n, m] and t ∈ Σ  [m, k]. Define the concatenation L·t of L and t by induction on t as follows: L ·  m = { n }

,

L · πim = L; πim (for every i = 1, . . . , m), L · (t σ) = (L · t ); εk σ (for every k  ≥ 0, t ∈ Σ  [m, k  ], and σ ∈ Σk ), L · t1 , . . . , tk = L · t1 × . . . × L · tk (for every t1 , . . . , tk ∈ Σ  [m, 1]). If L ⊆ Σ  [m, k], then L · L =

t∈L

L · t is the concatenation of L and L .

The construction of the forest concatenation might seem unnatural, but the usual tree concatenation [6,11] is defined in a similar way: Different occurrences of the same 0-ary symbol can be replaced by different trees. Although the recognizable forest languages are not closed under the naive concatenation, they are closed under concatenation. This means that also Rec(Σ  ) forms a cartesian category (see also [13]). Proposition 6. Let Σ be a ranked alphabet, and n, m, k ∈ IN. If L1 ∈ Rec(Σ  )[n, m] and L2 ∈ Rec(Σ  )[m, k], then L1 · L2 ∈ Rec(Σ  )[n, k]. For the proof we need the concept of normalized fsfa, where there is only one input state tuple and only one output state tuple and there are no transitions from a final state or into an initial state. Then, the two normalized fsfa for L1 and L2 are connected. Now we can define a generalization of Kleene’s star operation as a closure operation for the concatenation. For the concatenation operation of a free monoid this does not bring any problems. Note that this makes sense only for languages L ⊆ Σ  [n, n], and we do not take the union of all Lz for 0 ≤ z < ω (as it is done for word languages) but use the operation instead.

724

L. Straßburger

Definition 12. For L ⊆ Σ  [n, n] define L0 = {εn } = {π1n , . . . , πnn } , Lz+1 = Lz · L for every z ≥ 0 ,

Lz . L = z≥0

This star operation is a generalization of both, Kleene’s star operation for word languages and the star operations for trees defined in [6]. Proposition 7. If L ∈ Rec(Σ  )[n, n], then L ∈ Rec(Σ  )[n, n]. The basic idea of the proof is to construct the normalized fsfa A for L and identify initial and final states. However, note that the situation is not entirely trivial because in general L(A ) = L. The reason for this is that the forests containing πin are removed in L(A ) because otherwise A would not be normal. We have to construct another automaton A , which reintroduces these forests.

5

Rational Forest Languages

The set of rational forest languages is the smallest set that contains the finite languages and that is closed under componentwise union, cartesian product, concatenation, and the star operation. Definition 13. Let Σ be a ranked alphabet. For every n, m ∈ IN, the set Rat(Σ  )[n, m] is the smallest set such that – ∅ ∈ Rat(Σ  )[n, m], and if t ∈ Σ  [n, m], then {t} ∈ Rat(Σ  )[n, m], – if L1 , L2 ∈ Rat(Σ  )[n, m], then L1  L2 ∈ Rat(Σ  )[n, m], – if L1 ∈ Rat(Σ  )[n, m1 ] and L2 ∈ Rat(Σ  )[n, m2 ], then L1 × L2 ∈ Rat(Σ  )[n, m1 + m2 ], – if L1 ∈ Rat(Σ  )[n, k] and L2 ∈ Rat(Σ  )[k, m], then L1 ·L2 ∈ Rat(Σ  )[n, m], – if L ∈ Rat(Σ  )[n, n], then L ∈ Rat(Σ  )[n, n]. The set of all rational forest languages over Σ is defined as Rat(Σ  ) = Rat(Σ  )[n, m] . n,m∈IN

From the propositions in the previous section it follows that for every ranked alphabet Σ and n, m ∈ IN we have that Rec(Σ  )[n, m] ⊆ Rat(Σ  )[n, m]. The following theorem says that the converse is also true. Theorem 1. Rat(Σ  )[n, m] = Rec(Σ  )[n, m]. In the proof of this theorem, the rational expression is constructed inductively on the size of the fsfa. The construction is inspired by Kleene’s original construction [1], but it is quite different from the one used by Thatcher and Wright [6].

A Kleene Theorem for Forest Languages

725

In particular, note that a priori there is no relation between Rat(Σ  )[n, 1] and the rational languages of [6]. Hence, Theorem 1 is not a consequence of the result in [6]. But from Theorem 1 and [6] it follows that Rat(Σ  )[n, 1] coincides with the rational languages of [6]. Example 5. For the forest language recognized by the automaton in Example 4 we can obtain the rational expression depicted in Fig. 3:   L = { 0 α}  { 0 α} · {π11 γ} × { 0 α} · {π12 , π12 , π22 σ } · {π12 , π22 σ} . By using Notation 1, we can write this more concisely as L = {α}  ({α} · {γ} × {α}) · {π12 , σ } · {σ}

.

Now we can immediately derive the main theorem of this paper. Theorem 2. Let Σ be a ranked alphabet. Then Rat(Σ  ) = Rec(Σ  ).

6

Conclusions and Future Work

The algebraic concepts used in this paper have been studied for a long time (e.g., [12,14,16,13]), but the construction of rational expression for the Kleene theorem (Theorem 2) in this paper has (up to my knowledge) not yet appeared in the literature. Apart from the independent interest of the result, the work is motivated by the following issues of future research. – The original motivation for proposing this new approach comes from the desire to give algebraic characterizations for certain classes of tree transducers (e.g., [21,22]). Their counterparts for word languages, e.g., general seqential machines [23], have been algebraicly characterized by using Kleene’s original theorem (see e.g. [24]). For tree transductions it is more difficult to find such characterizations because of the insufficient behaviour of the tree concatenation operation (see also [16]). The here proposed notion of rational expression allows to give an algebraic characterization of the transductions realized by sequential forest transducers [19], which are a generalization of a certain class of bottom-up tree transducers. In [16], Arnold and Dauchet encountered the same problem when studying bimorphisms for trees. Their solution uses magmoides. The structures Σ  and Rec(Σ  ) discussed in this paper are magmoides (see also [15]). – In [25], the result of [6] is generalized to trees over arbitrary semirings (as done in [4] for word automata). This raises the question whether also Theorem 2 can be proved for forests over arbitrary semirings. – Another important problem is whether the result can be extended to unranked trees and hedges [10,9] which are important for practical applications [7,8]. The notion of cartesian category already provides the right algebraic structure. We only have to add additional objects (infinite ordinals) to the category of forests.

726

L. Straßburger

– More generally, it is now possible to generalize the notion of recognizable and rational languages from the free cartesian category to any cartesian category, in the same sense as it had been generalized from the free monoid to any monoid [2,24]. The question is in which cases Theorem 2 holds. – The same question can be raised for the definability in monadic second order logic [6,26,7,9].

References 1. Kleene, S.C.: Representation of events in nerve nets and finite automata. In: Shannon, C.E., McCarthy, J. (eds.) Automata Studies, pp. 3–40. Princeton (1956) 2. Eilenberg, S.: Automata, Languages And Machines, vol. B. Academic Press, New York (1976) 3. Ochma´ nski, E.: Regular behaviour of concurrent systems. Bull. Europ. Assoc. Theoret. Comput. Sci. (EATCS) 27, 56–67 (1985) 4. Sch¨ utzenberger, M.P.: On the definition of a family of automata. Inform. And Control 4, 245–270 (1961) 5. Droste, M., Gastin, P.: The Kleene–Sch¨ utzenberger theorem for formal power series in partially commuting variables. Information and Computation 153, 47–80 (1999) 6. Thatcher, J.W., Wright, J.B.: Generalized finite automata theory with an application to a decision problem of second-order logic. Math. Systems Theory 2, 57–81 (1968) 7. Neven, F.: Automata, logic, and XML. In: Bradfield, J.C. (ed.) CSL 2002 and EACSL 2002. LNCS, vol. 2471, pp. 2–26. Springer, Heidelberg (2002) 8. Martens, W., Niehren, J.: On the minimization of XML schemas and tree automata for unranked trees. J. Comput. Syst. Sci. 73(4), 550–583 (2007) 9. Comon, H., Dauchet, M., Gilleron, R., L¨ oding, C., Jacquemard, F., Lugiez, D., Tison, S., Tommasi, M.: Tree automata techniques and applications (2007) (release October 12, 2007) 10. Courcelle, B.: On recognizable sets and tree automata. In: Nivat, M., Ait-Kaci, H. (eds.) Resolution of equations in algebraic structures, pp. 93–126. Academic Press, London (1989) 11. G´ecseg, F., Steinby, M.: Tree Languages. In: Rozenberg, G., Salomaa, A. (eds.) Handbook of Formal Languages, Beyond Words, vol. 3, pp. 1–68. Springer, Heidelberg (1997) 12. Lawvere, F.W.: Functorial semantics of algebraic theories. In: Proceedings of the National Academy of Sciences, USA. Volume 50., National Academy of Sciences, Summary of PhD thesis, pp. 869–872, Columbia University (1963) ´ 13. Bloom, S.L., Esik, Z.: Iteration Theories. Springer, Heidelberg (1993) ´ 14. Esik, Z.: An axiomatization of regular forests in the language of algebraic theories with iteration. In: Gecseg, F. (ed.) FCT 1981. LNCS, vol. 117, pp. 130–136. Springer, Heidelberg (1981) ´ 15. Esik, Z., Weil, P.: Algebraic recognizability of regular tree languages. Theoretical Computer Science 340, 291–321 (2005) 16. Arnold, A., Dauchet, M.: Morphisms et bimorphisms d’arbres. Theoretical Computer Science 20, 33–93 (1982) 17. Boja´ nczyk, M.: Forest expressions. In: Duparc, J., Henzinger, T.A. (eds.) CSL 2007. LNCS, vol. 4646, pp. 146–160. Springer, Heidelberg (2007)

A Kleene Theorem for Forest Languages

727

18. Eder, E.: Properties of substitutions and unifications. Journal of Symbolic Computation 1(1), 31–46 (1985) 19. Straßburger, L.: Rational forest languages and sequential forest transducers. Master’s thesis, Technische Universit¨ at Dresden (2000) 20. Perrin, D.: Finite Automata. In: van Leeuwen, J. (ed.) Handbook of Theoretical Computer Science. Formal Models and Semantics, vol. B, pp. 1–57. Elsevier Science Publishers, B.V., Amsterdam (1990) 21. Engelfriet, J.: Bottom-up and top-down tree transformations—a comparison. Mathematical Systems Theory 9(3), 198–231 (1975) 22. F¨ ul¨ op, Z., Vogler, H.: Syntax-Directed Semantics: Formal Models Based on Tree Transducers. Springer, Heidelberg (1998) 23. Ginsburg, S., Rose, G.F.: A characterisation of machine mappings. Can. J. of Math. 18, 381–388 (1966) 24. Berstel, J.: Transductions and Context-Free Languages. Leitf¨ aden der angewandten Mathematik und Mechanik LAMM, vol. 38. B.G. Teubner Stuttgart (1979) 25. Droste, M., Pech, C., Vogler, H.: A Kleene theorem for weighted tree automata. Theory Comput. Syst. 38(1), 1–38 (2005) 26. Thomas, W.: Languages, automata, and logic. In: Rozenberg, G., Salomaa, A. (eds.) Handbook of Formal Language Theory, vol. 3, pp. 389–456. Springer, Heidelberg (1997)

Determinization and Expressiveness of Integer Reset Timed Automata with Silent Transitions P. Vijay Suman and Paritosh K. Pandya Tata Institute of Fundamental Research, India

Abstract. -IRTA are a subclass of timed automata with  moves (-TA). They are useful for modelling global sparse time base used in timetriggered architecture and distributed business processes. In a previous paper [1], the language inclusion problem L(A) ⊆ L(B) was shown to be decidable when A is an -TA and B is an -IRTA. In this paper, we address the determinization, complementation and -removal questions for -IRTA. We introduce a new variant of timed automata called GRTA. We show that for every -IRTA we can effectively construct a language equivalent 1-clock, deterministic GRTA with periodic time guards (but having no  moves). The construction gives rise to at most a double exponential blowup in the number of locations. Finally, we show that every GRTA with periodic guards can be reduced to a language equivalent -IRTA with at most double the number of locations. Thus, -IRTA, periodic GRTA, and deterministic 1-clock periodic GRTA have the same expressive power and that they are all expressively complete with respect to the regular δ-languages. Equivalence of deterministic and nondeterministic automata also gives us that these automata are closed under the boolean operations.

1

Introduction

Timed automata (TA) are an extension of finite state automata with real-valued clocks. They have emerged as a standard theoretical model for real-time systems, and their formal properties have been well studied [2]. The expressive power of richer classes of timed automata such as timed automata with  transitions (-TA) [3] and TA with periodic constraints [4] have also been explored. These extensions result in models which can elegantly specify periodic timed behaviours of the systems. Integer Reset Timed Automata (IRTA) are a syntactic subclass of timed automata which restrict clock resets to integral time points. Additionally, if  transitions are allowed, the resulting automata are called -IRTA. A recent paper showed that the notion of global but sparse time as used in time triggered architecture and distributed business processes can be naturally modeled in -IRTA (see [1]). The  transitions are crucial in modelling periodic timed activities. In the previous paper [1], it was shown that the language inclusion problem L(A) ⊆ L(B) is decidable with EXPSPACE complexity if A is an -TA and B is an -IRTA. The decision procedure relies upon an effectively computable A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 728–739, 2009. c Springer-Verlag Berlin Heidelberg 2009 

Determinization and Expressiveness of IRTA with Silent Transitions

729

symbolic representation of the timed language L of -TA over alphabet Σ by an untimed regular language f (L) over the extended alphabet Σ ∪ {δ, }. The finite state automata recognizing the untimed symbolic δ-languages can be called δ-automata. In this paper, we consider the questions of determinization, complementation and  removal of -IRTA. Note that, in general, all these questions are unsolvable for -TA [2,5,3]. Though silent transitions are useful in specifying periodic properties, the use of silent transitions cannot be justified in the scenario of deterministic modeling. Hence, our aim is to characterize timed languages recognized by -IRTA in terms of some suitable -free and deterministic species of timed automata. In the paper, we introduce a new variant of timed automata called Generalized Reset Timed Automata (GRTA) in which only the integer part of the clock is reset. Since the clock resets do not change the fractional parts of the clocks, the fractional values of all clocks remain equal in any configuration of a GRTA. The clocks measure the time since the last integral time point before it was reset. Moreover, to model periodic activity, we consider GRTA with periodic time guards and call the resulting model as Per-GRTA. As our main result, we give a construction of a deterministic, 1-clock PerGRTA B for any δ-automaton A such that f (L(B)) = L(A). This is used to prove that -IRTA can be effectively reduced to a language equivalent 1clock, deterministic Per-GRTA with at most double exponential blowup in the number of locations. It follows that -IRTA are closed under complementation. We also show that Per-IRTA are strictly less expressive than -IRTA. Hence, using the proposed GRTA as well as periodic time guards seem necessary for -free determinization of -IRTA. As our second main result, we show that every Per-GRTA can be reduced to a language equivalent -IRTA with at most doubling of the number of locations. This result builds upon the techniques for reducing periodic timed automata to -TA given by Choffrut and Goldwurm [4]. Putting all the results together, we conclude that -IRTA and Per-GRTA are expressively equivalent and they are expressively complete for the class of regular δ-languages. Our reduction also shows that, expressively, -IRTA and PerGRTA are contained within 1-clock, deterministic -TA. Moreover, equality of nondeterministic and deterministic automata in classes -IRTA and Per-GRTA implies that they are closed under boolean (intersection, union and complementation) operations. The paper also studies the expressive power of various subclasses of -IRTAand Per-GRTA. The relationships between these classes is depicted in Figure 1. We end the paper by showing that the question whether there exists an -IRTA which is language equivalent to a given -TA is undecidable. The question whether a given timed automaton is determinizable was already been shown to be undecidable [6]. Related Work. Finding determinizable and boolean closed sub-classes of timed automata has been an interesting quest. Alur et al [7] have shown that a subclass of timed automata called Event Recording Automata (ERA) can indeed be deter-

730

P.V. Suman and P.K. Pandya

1-Clock Deterministic -TA -IRTA = Per-GRTA = 1-Clk-Det-Per-GRTA

Per-IRTA

IRTA

GRTA

Fig. 1. Relationships between various classes. 1-Clk-Det-Per-GRTA denotes 1-Clock, Deterministic GRTA with Periodic guards.

minized with one exponential blowup in the automaton size. Our previous work [1] showed that -IRTA and ERA are expressively incomparable. Ouaknine and Worrell [8] as well as Lasota and Walukiewicz [9] have defined 1-clock alternating timed automata which are boolean closed. Moreover the emptiness of these automata is decidable but with Non-primitive-recursive complexity. Laroussinie et al [10] have shown that emptiness checking for 1-clock TA is NLOGSPACEcomplete although these automata are not closed under complementation. The language inclusion and universality of 1-clock timed automata has also been studied [11] and shown to be decidable with Non-primitive-recursive complexity.

2

Preliminaries

Definition 1 (Timed Word). A finite timed word over Σ is defined as ρ = (σ, τ ), where σ = σ1 . . . σn is a finite sequence of symbols in Σ and τ = τ1 . . . τn is a finite monotone sequence of non-negative real numbers. τi represents the time stamp of the occurrence of the event σi . For convenience of presentation we assume a default initial time stamp τ0 = 0, prefixed to any sequence of time stamps τ = τ1 . . . τn . Definition 2 (Timed Automata). A timed automaton A is a tuple (L, L0 , Σ, C, E, F ) where (i) L is a finite set of locations, (ii) L0 ⊆ L is the set of initial locations, (iii) Σ is a finite set of symbols (called alphabet), (iv) C is a finite set of real valued clocks, (v) E ⊆ L × L × Σ × Φ(C) × 2C is the set of transitions. An edge e = (l, l , a, ϕ, λ) represents a transition from the source location l to the target location l on input symbol a. The set λ ⊆ C gives the set of clocks that are reset with the transition and, ϕ is a guard over C, and (vi)F ⊆ L is the set of final locations. Let x represent a clock in C and k represent a natural number. Φ(C) is the set of constraints ϕ defined by ϕ := x = k|x ≤ k|x ≥ k|x < k|x > k|ϕ ∧ ϕ.

Determinization and Expressiveness of IRTA with Silent Transitions

731

Definition 3 (Clock Interpretation). Let C be the set of clocks. A clock interpretation ν : C → R≥0 maps each clock x ∈ C to a non-negative real number. A state of A is a pair (l, ν) such that l ∈ L and ν is a clock interpretation over |C| C. The state space of A is L × R≥0 . The state of a timed automaton can change in 2 ways: t

1. Due to elapse of time: for a state (l, ν) and a real-number t ≥ 0, (l, ν) −→ (l, ν + t). This kind of transition is called a timed transition. 2. Due to a location-switch: for a state (l, ν) and an edge (l, l , a, ϕ, λ) such that a ν |= ϕ, (l, ν) −→ (l , ν[λ := 0]). We call such a transition, a Σ-transition. Here (ν + t)(x) = ν(x) + t and, ν[λ := 0](x) = 0, ∀x ∈ λ, and remains unchanged ∀x ∈ (C\λ). Definition 4 (Run, Word, Language). A run r of a timed automaton is τ1 e1 (l0 , ν1 ) −→ a sequence of alternating timed and Σ transitions: (l0 , ν0 ) −→ τ −τ

τn −τn−1

e

2 1 n  (l1 , ν2 ) · · · (ln−1 , νn−1 ) −→ (ln−1 , νn ) −→ (ln , νn ) with l0 ∈ L0 (l1 , ν1 ) −→ and ν0 is such that ν0 (x) = 0, ∀x ∈ C. The run r is accepting iff ln ∈ F . Corresponding to each run, there is a timed word (σ1 , τ1 ), (σ2 , τ2 ), · · · , (σn , τn ) where σi is the label over the edge ei , and τi is the time stamp of σi . A finite timed word ρ = (σ, τ ) is accepted by A iff there exists an accepting run over A, the word corresponding to which is ρ. The timed language L(A) accepted by A is defined as the set of all finite timed words accepted by A. 

We say that two automata are equivalent iff the (timed) languages accepted by them are the same. Let t be a non-negative real number. We use int(t) and f r(t) to denote respectively the integral part and the fractional part of t. We say that an edge is resetting if the set of clocks to be reset over it is nonempty. Definition 5 (IRTA). Integer reset timed automata are timed automata in which the guard over each resetting edge consists of an atomic constraint of the form x = c. In any run of an IRTA the clock resets happen only at integer time points. Definition 6 (GRTA). Generalized reset timed automata are a variant of timed automata wherein the clock resets are defined as follows. ν[λ := 0](x) = ν(x) − int(ν(x)), ∀x ∈ λ, and remains unchanged ∀x ∈ (C\λ). Since resets do not perturb the fractional values of the clocks, in any configuration that arises in a GRTA the clocks have equal fractional parts. Note that GRTA is a generalization of IRTA. Definition 7 (Periodic Clock Constraints). An atomic periodic clock constraint is in either of the following forms: ∃k ∈ N : x ∈ [a + kp, b + kp], ∃k ∈ N : x ∈ (a + kp, b + kp], ∃k ∈ N : x ∈ [a + kp, b + kp), or ∃k ∈ N : x ∈ (a + kp, b + kp), where a, b, p ∈ N.

732

P.V. Suman and P.K. Pandya

q2 , x = 1, {x}

, 0 < x < 1 q1

, 0 < x < 1 a, x = 0

a, ∃k ∈ N, x ∈ [1 + k, 1 + k], {x}

q3

q1

Fig. 2. An -IRTA and a Per-IRTA equivalent to it

Note that an aperiodic constraint can be expressed as a periodic constraint. For example, the constraint x ≥ 3 is equivalent to the periodic constraint ∃k ∈ N : x ∈ [3 + k, 4 + k). Definition 8 (Per-IRTA). Per-IRTA are IRTA wherein the atomic clock constraints can be periodic and, the guard over each resetting edge consists an atomic constraint of the form ∃k ∈ N : x ∈ [a + kp, a + kp]. In any run of a Per-IRTA, the clock resets happen only at integer time points. Definition 9 (Per-GRTA). Per-GRTA are GRTA wherein the atomic clock constraints can be periodic Definition 10 (-IRTA, -GRTA). -IRTA and -GRTA are respectively generalizations of IRTA and GRTA, wherein transitions can have  as label to designate silent moves. While a run can have -transitions, these symbols or their time stamp are not recorded in the timed word corresponding to the run (see [3]). Figure 2 shows an -IRTA and a Per-IRTA both of which accept the language L1 = { (a, τ1 ) . . . (a, τn ) : τi − τi−1 is an integer greater than 0}. -IRTA formalize timed systems where the time stamps of events which occur in any open interval (i, i + 1) cannot be distinguished [1]. In this setting, we symbolically represent a timed word ρ over Σ by an untimed word f (ρ) over Σ ∪ {δ, }. In f (ρ) a  occurs at every integral time point and all the Σ events of ρ which occur at this time point immediately follow the symbol  in order. Moreover, before every  denoting the integral point i, there is a δ denoting the open interval (i − 1, i) and all events of ρ which occur within this open interval follow the symbol δ in order. Example 1 illustrates this representation. The formal definition of representation function f is given below. Firstly we define a δ-representation for a real number τ , and its extension for two real numbers τ1 ≤ τ2 . Definition 11. Let int(τ ) = k.  (δ)k if τ is integral, dt(τ )  (δ)k δ if τ is non-integral, Let τ1 ≤ τ2 be two real numbers. Then dte(τ1 , τ2 ) is the δ-pattern that is to be right concatenated to dt(τ1 ) to get dt(τ2 ).



Determinization and Expressiveness of IRTA with Silent Transitions

733

For example, if τ1 = 1.6 and τ2 = 2.7, then dt(τ1 ) = δδ while dt(2.7) = δδδ. Therefore, dte(τ1 , τ2 ) = δ. Definition 12. Given a timed word ρ = (σ, τ ), the map f (ρ) is defined as the 

untimed word w1 σ1 w2 σ2 . . . wn σn , where each wi is dte(τi−1 , τi ). Example 1. For example, let ρ1 = (a, 1.2), (b, 3.5), (c, 4), (d, 4.5), (e, 4.5), (f , 5.6), (g, 5.8)), ρ2 = (a, 0), (b, 0), (c, 0.5), (c, 0.6), (d, 2) and ρ3 = (a, 0), (b, 0), (c, 0.3), (c, 0.7), (d, 2) be three timed words. Then, f (ρ1 ) = δδaδδbcδd eδf g and f (ρ2 ) = f (ρ3 ) = abδccδd. Definition 13 (f -Equivalence). Two timed words ρ and ρ are said to be f equivalent, denoted by ρ ∼

 = ρ iff f (ρ) = f (ρ ). The central property of -IRTA is that its languages are closed under f -equivalence. Theorem 1. If A is an -IRTA and ρ ∼ = ρ then, ρ ∈ L(A) iff ρ ∈ L(A) ([1]).

3

δ-Regular Languages

A δ-word over Σ is a word over Σ ∪ {δ, } where ignoring the letters from Σ the δ and  strictly alternate and the first such symbol (if any) must be δ. Moreover, the last letter of the word must be from Σ. For example, aδbcabδc is a δ-word. Definition 14. Let || be shuffle operator in the classic regular expression theory. The set of all δ-words over Σ is given by (Σ ∗ || ((δ)∗ + δ(δ)∗ )).Σ. A regular set of δ-words is called a δ-regular language. A deterministic finite state automaton is called a δ-automaton iff the language accepted by it is δregular. q2 

δ q1

a

δ

q3

Fig. 3. A δ-automaton

Normalized δ-Automata. Let A be a given δ-automaton. We say that q1 δ reaches q2 by an extended time step of δ type, denoted q1 =⇒ q2 , if we have uδv q1 −→ q2 for some u, v ∈ Σ ∗ . Similarly, we can define extended time step of   type q1 =⇒ q2 . A state q of automaton A is said to be post(δ) provided all incoming extended time steps are of δ type. A state is said to be of post() type if all incoming extended time steps are of  type. By convention the initial

734

P.V. Suman and P.K. Pandya

state and all states reachable from it with only Σ-transitions are post()-type. In general, the automaton can have a state q with incoming time steps of both types (call such states mixed type). A δ-automaton is said to be normalized iff there are no mixed type states. It is easy to transform any δ-automaton to an equivalent normalized δ-automaton (See full version of this paper for details). δ-Languages of -IRTA. The abstraction f mapping a timed word ρ into a δ-word f (ρ) was defined in the previous section. This also maps a timed regular language L into a δ-language f (L). The following results were proved in a previous paper [1]. Proposition 1. For every A ∈ -TA we can effectively construct normalized δ-automaton B such that L(B) = f (L(A)). Thus, f (L(A)) is δ-regular. Moreover, if A is an -IRTA, then f −1 (f (L(A))) = L(A). (In general for -TA, we can only show that f −1 (f (L(A))) ⊇ L(A)). Complexity. If k is the maximum constant appearing in the constraints of A = (L, L0 , Σ, C, E, F ) then, the number of states in B is upperbounded by |C|+1 . We refer the reader to the original paper for details. Thus the 24.|L|.(k+1) reduction from -IRTA to normalized (deterministic) δ-automaton results in doubly exponential blowup in number of locations. Proposition 2. The following structural properties hold for a normalized δautomaton A. 1. A is bipartite with the partitions corresponding post(δ) and post() states. The initial state is in post() partition. 2. The Σ-transitions stay within the same partition. A δ-transition takes only a post()-type state to only a post(δ)-type state and a -transition takes only a post(δ)-type state to only a post()-type state. 3. Let Grδ (q) be the subgraph of A which consists of states reachable from a state q with only δ and -transitions. Either Grδ (q) is a simple path or is a simple path ending with a loop. Hence, a state cannot be part of two different pure δ-loops. 

In the rest of the paper, we assume that the δ-automaton is always normalized.

4

Per-GRTA and -Removal

Our aim is to characterize timed languages recognized by -IRTA in terms of some suitable deterministic class of timed automata (See [2,4] for definition) which are also -free. One main use of the -transitions is to model periodic timed activity. Periodic timed constraints (See Definition 7) have been introduced as a direct construct for expressing periodic activities [4]. Hence Per-IRTA can be considered as a candidate for -free determinization of -IRTA. Unfortunately Lemma 1 below shows that the class Per-IRTA does not have the power to express all -IRTA languages.

Determinization and Expressiveness of IRTA with Silent Transitions

735

In Section 2, a variant of timed automata with periodic constraints, called Per-GRTA, were introduced. In this section we show a reduction from -IRTA to equivalent 1-clock, deterministic Per-GRTA. Lemma 1. Per-IRTA  -IRTA. Proof. Consider the -IRTA A shown in Figure 4 (first automaton). L(A) = { (a, τ1 ), (b, τ2 ) : τ1 and τ2 are non-integral, and are separated by at least one integer}. Assume to the contrary that there exists an IRTA with periodic clock constraints B = (L, L0 , {a, b, }, C, E, F ) accepting L(A). For n ∈ N, let Ln represent the set of locations reachable from L0 on the event a at time τ1 , where τ1 ∈ (n, n + 1). Note that since A is an IRTA, the subset Ln ∈ 2L is completely determined by the interval (n, n + 1). Also note that since the first time stamp of the words in L(A) can be any non-integral time point, Ln is nonempty for each n. Let k be the maximum constant appearing in B (max. is calculated ignoring the periods). Since 2L is finite and the number of integers is infinite, there exist k1 and k2 such that k < k1 < k2 and Lk1 = Lk2 . Let τ1 ∈ (k1 , k1 + 1) and τ2 ∈ (k2 , k2 + 1) be two randomly selected time stamps. Then we know that τ1 (l0 , ν1 )

(a, τ1 ), (b, τ2 ) ∈ L(B). i.e., there exists an accepting run (l0 , ν0 ) −→ e1 τ2 −τ1 e2 −→ (l1 , ν1 ) −→ (l1 , ν2 ) −→ (lf , ν2 ) corresponding to this word, where ∀x ∈ C, ν1 (x) = τ1 and ν2 (x) = τ2 . Note that none of the clocks would have been reset on e1 or e2 since they occur at a nonintegral time point. Since Lk1 = Lk2 the τ2 e1 e2 0 (l0 , ν2 ) −→ (l1 , ν2 ) −→ (l1 , ν2 ) −→ (lf , ν2 ) is also acmodified run (l0 , ν0 ) −→ 

cepting. Hence the word (a, τ2 ), (b, τ2 ) ∈ L(B), which is a contradiction. , x = 1, {x}

l0

l0

, x = 1, {x}

a, 0 < x < 1

l1

, x = 1, {x}

a, ∃k ∈ N : x ∈ (k, k + 1), {x}

l1

l2

b, 0 < x < 1

l3

b, ∃k ∈ N : x ∈ (k + 1, k + 2)

l2

Fig. 4. An -IRTA and a Per-GRTA equivalent to it

4.1

Construction of 1-Clock Deterministic Per-GRTA

Let L be a δ-regular language and let A be the normalized δ-automaton accepting L. In this section we show how to construct a deterministic 1-clock Per-GRTA B from A which accepts the timed version of L. We first define constraint which decodes the timing information represented by δ-paths in A. Definition 15 (Time Distance). Let π be a simple, pure δ-path from q1 to q2 in Det(A δ ). Let m be the number of -transitions in π. Then,

736

P.V. Suman and P.K. Pandya

⎧ [m, m] ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ (m, m + 1) ⎪ ⎪ ⎨

if q2 is post()-type, and q2 is not in a pure δ-loop if q2 is post(δ)-type, and q2 is not in a pure δ-loop constraint(π)  ∃k ∈ N[m + pk, m + pk] if q2 is post()-type, and q2 is ⎪ ⎪ ⎪ ⎪ in a pure δ-loop with p ’s ⎪ ⎪ ⎪ ⎪ ∃k ∈ N(m + pk, m + pk + 1) if q ⎪ 2 is post(δ)-type, and q2 is ⎪ ⎩ in a pure δ-loop with p ’s Construction: Let A = (Q, q0 , Σ ∪ {δ, }, E, F ) be the given normalized δautomaton. We construct the deterministic 1-clock GRTA B = (L, l0 , Σ, {x}, E  , F ) as follows. Note that the number of locations in B is at most equal to the number of states in the A. – L = {q0 } ∪ {q ∈ Q: q has an incoming Σ-transition in A}. l0 = q0 . – There is an edge (q1 , q2 , a, ϕ, {x}) ∈ E  iff there exists q3 ∈ Q such that (i) there is a simple, pure δ-path π from q1 to q3 in A, (ii) the edge (q3 , a, q2 ) ∈ E, and (iii) ϕ is defined as x ∈ constraint(π). 

Figure 2 shows the Per-GRTA (which is in this case a Per-IRTA) constructed from the δ-automaton in Figure 3. In the following we prove that the resultant automaton B is deterministic and that f (L(B)) = L(A). Lemma 2. The automaton B constructed above is deterministic. Proof. Let q be a location in B and let e1 = (q, q1 , a, ϕ1 , {x}) and e2 = (q, q2 , a, ϕ2 , {x}) be two edges out of q. Note that this is the case iff there is a simple, pure δ-path π1 (π2 ) from q to q1 (q2 ) such that constraint(π1 ) = [ϕ1 ] (constraint(π2 ) = [ϕ2 ]) and there is an edge (q1 , a, q1 ) ((q2 , a, q2 )) in A. We assume w.l.o.g. that q1 = q2 and since A is deterministic this implies that q1 = q2 . We consider the case where both q1 and q2 are part of pure δ-loops. The argument is similar in the other cases. From Proposition 2 it follows that q1 and q2 are part of the same pure δ-loop. Hence constraint(π1 ) and constraint(π2 ) are periodic sets with the same period p but their offsets modulo p are distinct. Hence ϕ1 and ϕ2 are disjoint. 

Given a run, let (l, ν)t denote that configuration (l, ν) arises in the given run at time t. π

e

Lemma 3. Let π be a pure δ-path in A. There exists a superstep q1 =⇒ q2 −→ τ2 −τ1

e

q3 where e = (q2 , a, q3 ), in A iff there exists a step (q1 , ν1 )τ1 −→ (q1 , ν2 )τ2 −→ (q3 , ν3 )τ2 where e = (q1 , q3 , a, ϕ, {x}), in B such that word(π) = dte(τ1 , τ2 ).

 Theorem 2. f (L(B)) = L(A). The number of locations in B is at most the number of states in A. Proof. We use induction over steps of B and supersteps of A. Using Lemma 3 we can establish that there exists an accepting run over r over a timed word ρ = (σ1 , τ1 ) . . . (σn , τn ) in B iff there exists a corresponding accepting run r over the word ρ = w1 σ1 w2 σ2 . . . wn σn in A such that (a) the states arising

Determinization and Expressiveness of IRTA with Silent Transitions

737

after supersteps in r are the locations of states arising after steps in r, and (b) wi = dte(τi−1 , τi ). From the definition of f it follows therefore that f (ρ) = ρ . Corollary 1. For every -IRTA A we can effectively construct a language equivalent 1-clock, deterministic Per-GRTA B with at most double exponential blowup in number of locations. The corollary follows directly using Proposition 1 and Theorem 2. The size bound is an improvement over the triply exponential bound for determinization for the subclass IRTA given in [12]. Note that the reduction is via δ-automata and a direct translation from -IRTA to Per-GRTA seems nontrivial.

5

From Per-GRTA to -IRTA

In this section we show that for every Per-GRTA an equivalent -IRTA can be effectively constructed. Our construction is in two parts. Part 1 converts PerGRTA into -GRTA making use of the technique of [4] originally introduced for showing that Per-TA is a subclass of -TA. Part 1 is carried out in two steps given below. In the second part the resulting -GRTA is reduced to an -IRTA. Part 1, Step 1: The periodic guards can be put in canonical form such that there exists a common period p and each constraint consists of conjunctions of atomic constraints of the following form (where 0 ≤ i < p): (i)x = i, (ii)x ∈ (i, i+1), (iii)∃k ∈ N : x ∈ [i+kp, i+kp], (iv)∃k ∈ N : x ∈ (i+kp, i+1+kp). Note that because of introduction of disjunction in making the guards canonical edges may have to be split into multiple edges (See [4] for the details and correctness of this construction). Part 1, Step 2: For each clock x, a new clock x is introduced which keeps track of the value of x modulo p. Hence the periodic constraints over x could be replaced by aperiodic constraints over x, of the following form: (i) x = i, (ii) x ∈ (i, i + 1). Additional transitions labelled with  are introduced which reset x whenever x = p. If an edge has two conjuncts of the form x = i and y ∈ (j, j + 1) then, such a guard is not satisfiable as fractional parts of all clocks are equal, and such edges can be deleted. Hence the constraints over edges in the resultant automaton are either uniformly of the form x = i or uniformly of the form x ∈ (i, i + 1). We call the former edges integral edges and the later kind of edges nonintegral edges. Proposition 3. Let A be obtained after applying Step 1 and Step 2 to a given Per-GRTA A. Then, L(A ) = L(A). 

Part 2: We intend to show that one can effectively construct an -IRTA B which is equivalent to A . The idea of the construction is to replace a resetting nonintegral edge by two consecutive edges. The first edge is an -transition which does the required resetting at the last integral time point (say t). The second transition is labeled by the same event as the original edge. The constraint over this edge makes sure that the transition occurs in the unit interval (t, t + 1). Let

738

P.V. Suman and P.K. Pandya

ϕ be the constraint 



x ∈ (ix , ix + 1). Then base(ϕ) represents the constraint

x∈X

x = ix and ext(ϕ) represents the constraint

x∈X



0 < x < 1.

x∈X

Construction: Let A = (L, L0 , Σ, C, E, F ). Let E  be the set of resetting nonintegral edges in E. The automaton B = (L , L0 , Σ, C, E  , F ) is defined as follows. – L = L ∪ {le : e ∈ E  }. – E  = (E \ E  ) ∪ {(l1 , le , , base(ϕ), λ), (le , l2 , σ, ext(ϕ), {}): e = (l1 , l2 , σ, ϕ, λ) ∈ E  }. Lemma 4. Let e = (l1 , l2 , σ, ϕ, λ) be a resetting nonintegral edge in A . There τ2 −τ1 e exists a step (l1 , ν1 )τ1 −→ (l1 , ν2 )τ2 −→ (l2 , ν3 )τ2 in A iff there exists a double i−τ e2 e τ2 −i 1 (le , μ2 )i −→ (le , μ3 )τ2 −→ (l2 , ν3 )τ2 in B, where step (l1 , ν1 )τ1 −→1 (l1 , μ1 )i −→ i = int(τ2 ), e1 = (l1 , le , , base(ϕ), λ) and e2 = (le , l2 , σ, ext(ϕ), {}). 

Lemma 5. L(B) = L(A ). Proof. We observe that (i) the edges which are not resetting nonintegral in A are replicated in B, and (ii) each new location le is not part of any edges except those from and to the source and target of e. Let ρ be a timed word. ρ ∈ L(A ) iff there exists an accepting run for ρ over A . By induction on the number of steps/double steps and Lemma 4 it follows that such a run exists iff there exists an accepting run over B for ρ. Note that the -transitions are not accounted for in a timed word. 

Corollary 2. It follows from Proposition 3 and Lemma 5 that given a PerGRTA A an -IRTA B can be effectively constructed such that L(A) = L(B) with at most double the number of locations. 

6

Expressiveness

Corollary 3. From Corollaries 1 and Corollary 2, it follows that Per-GRTA = -IRTA.

 The technique of Proposition 3 can be used to prove  − P er − GRT A =  − GRT A = P er − GRT A. The following Lemma and Figure 1 summarize the relationships between various classes of automata introduced in this paper. Lemma 6. (i) IRTA  Per-IRTA, (ii) GRTA  Per-IRTA, (iii) IRTA  GRTA and (iv) Per-IRTA  GRTA. 

Theorem 3. It is undecidable to determine whether for a given timed automaton there exists an -IRTA equivalent to it. Proof. We observe that the problem L(A) ⊆ L(B)?, where A is an -IRTA and B is a TA, is undecidable (follows from undecidability of universality of

Determinization and Expressiveness of IRTA with Silent Transitions

739

timed automata). We reduce this problem to the above problem. We know that L(A) ⊆ L(B) iff L(A ∩ B) = L(A). Given an instance of L(A) ⊆ L(B)?, we ask whether A ∩ B which is a timed automaton, is -IRTA-representable. If the answer is No then clearly L(A ∩ B)  L(A). Hence L(A)  L(B). If the answer is Yes then we can check whether L(A ∩ B) ⊇ L(A) by the method of [1]. In this method, we can directly construct the δ-automaton for f (L(A ∩ B)) without constructing an equivalent -IRTA. 

Essentially the same proof can be used to show that determining the existence of -IRTA/IRTA/GRTA/Per-GRTA equivalent to given TA/-TA is undecidable as well. Acknowledgements. We thank Kamal Lodaya for his helpful comments.

References 1. Suman, P.V., Pandya, P.K., Krishna, S.N., Manasa, L.: Timed automata with integer resets: Language inclusion and expressiveness (LNCS 5215). In: Cassez, F., Jard, C. (eds.) FORMATS 2008. LNCS, vol. 5215, pp. 78–92. Springer, Heidelberg (2008) 2. Alur, R., Dill, D.L.: A theory of timed automata. Theoretical Computer Science 126(2), 183–235 (1994) 3. Berard, B., Petit, A., Gastin, P., Diekert, V.: Characterization of the expressive power of silent transitions in timed automata. Fundamenta Informaticae 36(2-3), 145–182 (1998) 4. Choffrut, C., Goldwurm, M.: Timed automata with periodic clock constraints. Journal of Automata, Languages and Combinatorics 5(4), 371–404 (2000) 5. Bouyer, P., Haddad, S., Reynier, P.A.: Undecidability results for timed automata with silent transitions. Research Report LSV-07-12, Laboratoire Sp´ecification et V´erification, ENS Cachan, France, 22 pages (2007) 6. Finkel, O.: Undecidable problems about timed automata. In: Asarin, E., Bouyer, P. (eds.) FORMATS 2006. LNCS, vol. 4202, pp. 187–199. Springer, Heidelberg (2006) 7. Alur, R., Fix, L., Henzinger, T.A.: Event-clock automata: a determinizable class of timed automata. Theoretical Computer Science 211(1–2), 253–273 (1999) 8. Ouaknine, J., Worrell, J.: On the decidability of metric temporal logic. In: LICS 2005: Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science, Washington, DC, USA, pp. 188–197. IEEE Computer Society, Los Alamitos (2005) 9. Lasota, S., Walukiewicz, I.: Alternating timed automata. ACM Trans. Comput. Logic 9(2), 1–27 (2008) 10. Laroussinie, F., Markey, N., Schnoebelen, P.: Model checking timed automata with one or two clocks. In: Gardner, P., Yoshida, N. (eds.) CONCUR 2004. LNCS, vol. 3170, pp. 387–401. Springer, Heidelberg (2004) 11. Ouaknine, J., Worrell, J.: On the language inclusion problem for timed automata: Closing a decidability gap. In: LICS 2004: Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science, Washington, DC, USA, pp. 54–63. IEEE Computer Society, Los Alamitos (2004) 12. Suman, P.V., Pandya, P.K., Krishna, S.N., Manasa, L.: Determinization of timed automata with integral resets. Research Report TIFR-PPVS-GM-2007/4, TIFR (2007)

One-Clock Deterministic Timed Automata Are Efficiently Identifiable in the Limit Sicco Verwer, Mathijs de Weerdt, and Cees Witteveen Delft University of Technology {S.E.Verwer,M.M.deWeerdt,C.Witteveen}@tudelft.nl

Abstract. We study the complexity of identifying (learning) timed automata in the limit from data. In previous work, we showed that in order for timed automata to be efficiently identifiable in the limit, it is necessary that they are deterministic and that they use at most one clock. In this paper, we show this is also sufficient: we provide an algorithm that identifies one-clock deterministic timed automata efficiently in the limit.

1

Introduction

Timed automata [1] (TAs) are finite state models that model timed events using an explicit notion of time. They can be used to model and reason about real-time systems [2]. In practice, however, the knowledge required to completely specify a TA model is often insufficient. An alternative is to try to induce the specification of a TA from observations. This approach is also known as inductive inference. The idea behind inductive inference is that it is often easier to find examples of the behavior of a real-time system than to specify the system in a direct way. Inductive inference then provides a way to find a TA model that characterizes the (behavior of the) real-time system that produced these examples. In our case, we can monitor the occurrences of the events in a real-time system. This results in a set of labeled (positive and negative) time stamped event sequences. The exact problem we want to solve is to find the TA model that (most likely) produced this data. This is called TA identification. Naturally, we want to solve this problem in an efficient way, i.e., without requiring exponential amounts of space or time. Unfortunately, identifying a TA efficiently is difficult due to the fact that the identification problem for non-timed deterministic finite state automata (DFAs) from a finite data set is already NP-complete [3]. This property easily generalizes to the problem of identifying a TA (by setting all time values to 0). Thus, unless P = N P , a TA cannot be identified efficiently from finite data. Even more troublesome is the fact that the DFA identification problem from finite data cannot even be approximated within any polynomial [4]. Hence (since this also generalizes), the TA identification problem from finite data is also inapproximable. However, both of these results require that the input for the identification problem is finite. While in normal decision problems this is very natural, in an identification problem the amount of input data is somewhat arbitrary: more A.H. Dediu, A.M. Ionescu, and C. Mart´ın-Vide (Eds.): LATA 2009, LNCS 5457, pp. 740–751, 2009. c Springer-Verlag Berlin Heidelberg 2009 

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

741

data can be sampled if necessary. Therefore, it makes sense to study the behavior of an identification process when it is given more and more data. The framework that studies this behavior is called identification in the limit [5]. The identifiability of many interesting models (or languages) have been studied within the framework of learning in the limit. For instance, DFAs have been shown to be efficiently identifiable in the limit from labeled examples [6], but non-deterministic finite state automata (NFAs) have been shown not to be efficiently identifiable in this way [7]. Because of this, we restrict our attention to deterministic timed automata (DTAs). Unfortunately, in previous work we have shown that DTAs in general cannot be identified efficiently in the limit [8]. The argument we used was based on the existence of DTAs such that languages of these DTAs only contain examples of length exponential in the size of the DTA. Therefore, if we intend to identify the full class of DTAs, we will sometimes require an exponential amount of data in order to converge to the correct DTA. However, this argument no longer holds if the DTAs contain at most one timed component, known as a clock. In fact, in the same work, we even proved that the length of the shortest string in the symmetric difference of two one-clock DTAs (1-DTAs) can always be bounded by a polynomial. DTAs with this property are called polynomially distinguishable. This is a very important property for identification purposes because to identify a model is basically to distinguish models from each other based on examples. We have shown that this is a necessary requirement for efficient identification in the limit [8]. In this paper, we provide an algorithm that identifies 1-DTAs efficiently in the limit. The proof of convergence of this algorithm is based on the polynomial distinguishability of 1-DTAs. The algorithm is an important step in the direction of being able to identify real-time systems efficiently. To the best of our knowledge, our result is the first positive efficiency result for identifying timed automata. Moreover, we do not know of any other algorithm that identifies the complete structure of a timed automaton, including the clock resets. The paper is organized as follows. We start with a brief introduction to 1DTAs (Section 2), and a formal explanation of efficient identifiability in the limit (Section 3). We then describe our algorithm for identifying 1-DTAs (Section 4), and give the sketch of a proof that it converges to the correct 1-DTA efficiently in the limit(Section 5). We end our paper with some conclusions (Section 6).

2

Deterministic One-Clock Timed Automata

A timed automaton (TA) [1] is an automaton that accepts (or generates) strings with event-time value pairs, called timed strings. A timed string τ over a finite set of symbols Σ is a sequence (a1 , t1 )(a2 , t2 ) . . . (an , tn ) of symbol-time value pairs (ai , ti ) ∈ Σ × N.1 Each time value ti in a timed string represents the time passed until the occurrence of symbol ai since the occurrence of the previous symbol ai−1 . We use τi = (a1 , t1 ) . . . (ai , ti ) to denote the prefix of length i of τ . 1

Sometimes R is used as a time domain for TAs. However, for identification of TAs N is sufficient since, in practice, we always measure time using finite precision.

742

S. Verwer, M. de Weerdt, and C. Witteveen a reset

q0

a reset

q1

a x5

b x
2

q2

q3

b reset

Fig. 1. A deterministic one-clock timed automaton. The start state q0 is denoted by an arrow pointing to it from nowhere. The final state q3 has two circles instead of one. The arrows represent transitions. The labels, clock guards, and clock resets are specified for every transition. When no guard is specified, the guard is always satisfied.

In TAs, timing conditions are added using a finite set X of clocks and one clock guard on every transition. For the purpose of this paper, i.e., identifying one-clock deterministic timed automata, we focus on the case where the TAs are deterministic and contain at most a single clock. Such a TA is called a deterministic one-clock timed automata (1-DTA). In TAs, valuation mappings v : X → N are used to obtain the value of a clock x ∈ X. Since we use only a single clock x, we use v instead of v(x) to denote the value of x. Every transition δ in a 1-TA contains a boolean value known as a reset value. When a transition δ fires (or occurs), and the reset value of δ is set to true, then the value of x is set to 0, i.e., v := 0. In this way, x is used to record the time since the occurrence of some specific event. Clock guards are then used to change the behavior of the 1-DTA depending on the value of x. A clock guard g = c ≤ x ≤ c is a boolean constraint on the value of x, where c ∈ N and c ∈ N ∪ {∞} are constants.2 A valuation v is said to satisfy a clock guard g, if whenever each occurrence of x in g is replaced by v the resulting statement is true. A deterministic one-clock timed automaton is defined as follows: Definition 1. A deterministic one-clock timed automaton (1-DTA) is a tuple A = Q, x, Σ, Δ, q0 , F , where Q is a finite set of states, x is a clock, Σ is a finite set of symbols, Δ is a finite set of transitions, q0 is the start state, and F ⊆ Q is a set of final states. A transition δ ∈ Δ is a tuple q, q  , a, g, r, where q, q  ∈ Q are the source and target states, a ∈ Σ is a symbol, called the transition label, g is a clock guard, and r ∈ {true, false} is a reset value. Since A is deterministic, for every source state q ∈ Q, every label a ∈ Σ, and every valuation v ∈ N, there exists at most a single transition q, q  , a, g, r ∈ Δ such that v satisfies g. Figure 1 shows an example of a 1-DTA. Like a DFA, a 1-DTA moves from state to state by firing state transitions δ ∈ Δ that connect these states. However, in addition, a 1-DTA is capable of remaining in the same state q for a while. While doing so, the valuation v of its clock x increases. We call this action of staying in the same state a time transition. A time transition of t time units increases the valuation v of x by t, i.e. v := v + t. One can view a time transition as moving 2

Since we use the natural numbers to represent time open (x < c) and closed (x ≤ c) one-clock timed automata are equivalent.

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

743

from one timed state (q, v) to another timed state (q, v + t) while remaining in the same untimed state q. The length t of time transitions corresponds to the time values in a timed string. More precisely, the occurrence of a timed symbol (a, t) in a timed string means that before firing a transition δ labeled with a, the 1-DTA makes a time transition of t time units. After such a time transition, δ can only fire if its guard g is satisfied by v + t. The exact behavior of a 1-DTA is defined by what is called a run of a 1-DTA: Definition 2. A (finite) run of a 1-DTA A = Q, x, Σ, Δ, q0 , F  over a timed string τ = (a1 , t1 ) . . . (an , tn ) is a sequence of timed states and transit1 a1 tn tions (q0 , v0 ) −→ (q0 , v0 + t1 ) −→ (q1 , v1 ) . . . (qn−1 , vn−1 ) −→ (qn−1 , vn−1 + an tn ) −→ (qn , vn ), such that for all 1 ≤ i ≤ n there exists a transition δi = qi−1 , qi , ai , g, r ∈ Δ such that vi−1 + ti satisfies g, v0 = 0, and vi = 0 if r = true, vi = vi−1 + ti otherwise. ai+1

In a run the subsequence (qi , vi + t) −→ (qi+1 , vi+1 ) represents a state transition like in a finite automaton without time. When this occurs, the timed string τ is said to fire a transition δ with valuation vi +t to another timed state (qi+1 , vi+1 ). ti+1

The time transitions of a 1-DTA are represented by (qi , vi ) −→ (qi , vi +ti+1 ). We say that a timed string τ reaches a timed state (q, v) in a TA A if there exist two t

time values t ≤ t such that (q, v  ) −→ (q, v  + t ) occurs somewhere in the run of A over τ and v = v  + t. If a timed string reaches a timed state (q, v) in A for some valuation v, it also reaches the untimed state q in A. A timed string ends in the last (timed) state it reaches, i.e., (qn , vn ) or qn . Notice that timed states in 1-DTAs are similar to the (untimed) states in DFAs: at any point during the run of a timed string τ , the state τ ends in depends on the current timed state and the remaining suffix of τ . A timed string τ is accepted by a 1-DTA A if τ ends in a final state, i.e., if qn ∈ F . The set of all strings τ that are accepted by A is called the language L(A) of A. Example 1. Consider the TA A of Fig. 1. The run of A over the timed string τ = 5 a 6 a (a, 5)(a, 6)(a, 2)(b, 2) is given by: (q0 , 0) −→ (q0 , 5) −→ (q1 , 0) −→ (q1 , 6) −→ 2

a

2

b

(q2 , 6) −→ (q2 , 8) −→ (q2 , 0) −→ (q2 , 2) −→ (q3 , 2). Since q3 is a final state, it holds that τ ∈ L(A). Note that q3 cannot be reached directly after reaching q2 from q1 : the clock guard to q2 is satisfied by a valuation v greater than 4, while the guard of the transition to q3 requires v to be less than 3.

3

Efficient Identification in the Limit

An identification process tries to find (learn) a model that explains a set of observations (data). The ultimate goal of such a process is to find a model equivalent to the actual concept that was responsible for producing the observations, called the target concept. In our case, we try to find a 1-DTA model A that is equivalent to a target language Lt , i.e., L(A) = Lt . If this is the case, we say that Lt is identified correctly. We try to find this model using labeled data: an input sample

744

S. Verwer, M. de Weerdt, and C. Witteveen

S for Lt is a pair of finite sets of positive examples S+ ⊆ Lt and negative examples S− ⊆ LC t = {τ | τ ∈ Lt }. We modify the non-strict set-inclusion operators for input samples such that they operate on the positive and negative examples   , S− ) then S ⊆ S  means separately, for example if S = (S+ , S− ) and S  = (S+   S+ ⊆ S+ and S− ⊆ S− . In addition, by τ ∈ S we mean τ ∈ S+ ∪ S− . The input of our 1-DTA identification problem is a pair of finite sets. Unfortunately, as we already mentioned in the introduction, the 1-DTA identification problem is inapproximable. Because of this, we study the behavior of a 1-DTA identification process that is given more and more data. The framework for studying such a process is called identification in the limit [5]. In this framework, we do not regard the complexity for any possible input sample S, but for any possible target language Lt . For every target language Lt , there exist many possible input samples S. An identification process A is called efficient in the limit (from polynomial time and data) if for any target language Lt , A requires time polynomial in the size of any input sample S for Lt , and if the smallest input sample S such that A converges to Lt can be bounded by a polynomial in the size of Lt . The size of a target language Lt is defined as the size of a smallest model for Lt . Efficient identifiability in the limit can be proved by showing the existence of polynomial characteristic sets [7]. Definition 3. A characteristic set Scs of a target language Lt for an identification algorithm A is an input sample (S+ , S− ) for Lt such that: – given Scs as input, algorithm A identifies Lt , i.e., A returns an automaton A such that L(A) = Lt , and – given any input sample S  ⊇ Scs as input, algorithm A still identifies Lt . Definition 4. A class of automata C is efficiently identifiable in the limit if there exist two polynomials p and q, and an algorithm A such that:  – given an input sample of size n = τ ∈S |τ |, A runs in time bounded by p(n), – and for every target language Lt = L(A), A ∈ C, there exists a characteristic set Scs of Lt for A of size bounded by q(|A|). In previous work [8], we showed that DTAs in general are not efficiently identifiable. The argument we used was based on the fact that there exists DTAs such that languages of these DTAs only contain examples (strings) of length exponential in the size of the DTA. This was used to prove that DTAs are not polynomially distinguishable: Definition 5. A class C of automata is polynomially distinguishable if there exists a polynomial function p, such that for any A, A ∈ C with L(A) = L(A ), there exists a τ ∈ (L(A) ∪ L(A )) \ (L(A) ∩ L(A )), such that |τ | ≤ p(|A| + |A |). We have also shown that polynomial distinguishability is a necessary requirement for efficient identification [8]. Because of this, we cannot identify DTAs efficiently. In addition, we have proved that 1-DTAs are polynomially distinguishable. Based on this result, we conjectured that 1-DTAs might be efficiently identifiable in

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

745

the limit. In the following sections, we prove this conjecture by first describing an algorithm for identifying 1-DTAs. We then prove the convergence of this algorithm, i.e., that it identifies 1-DTAs efficiently in the limit. This proof is based on the polynomial distinguishability of 1-DTAs.

4

Identifying 1-DTAs Efficiently in the Limit

In this section, we describe our ID 1DTA algorithm for identifying 1-DTAs from an input sample S. The main value of this algorithm is that: – given any input sample S, ID 1DTA returns in polynomial time a 1-DTA A that is consistent with S, i.e., such that S+ ⊆ L(A) and S− ⊆ L(A)C , – and if S contains a characteristic subsample Scs for some target language Lt , then ID 1DTA returns a correct 1-DTA A, i.e., such that L(A) = Lt . In other words, ID 1DTA identifies 1-DTAs efficiently in the limit. Note that, in a 1-DTA identification problem, the size of the 1-DTA is not predetermined. Hence, our algorithm has to identify the complete structure of a 1-DTA, including states, transitions, clock guards, and resets. Our algorithm identifies this structure one transition at a time: it starts with an empty 1-DTA A, and whenever an identified transition requires more states or additional transitions, these will be added to A. In this way, ID 1DTA builds the structure of A piece by piece. Since we claim that ID 1DTA identifies 1-DTAs efficiently, i.e., from polynomial time and data, we require that, for any input sample S for any target language Lt , the following four properties hold for this identification process: Property 1. Identifying a single transition δ requires time polynomial in the size of S (polynomial time per δ). Property 2. The number of such transition identifications is polynomial in the size of S (convergence in polynomial time). Property 3. For every transition δ, there exists an input sample Scs of size polynomial in the size of the smallest 1-DTA for Lt such that when included in S, Scs guarantees that δ is identified correctly (polynomial data per δ). Property 4. The number of such correct transition identifications that are required to return a 1-DTA A with L(A) = Lt is polynomial in the size of the smallest 1-DTA for Lt (convergence from polynomial data) . With these four properties in mind, we develop our ID 1DTA algorithm for the efficient identification of 1-DTAs. Pseudo code of this algorithm is shown in Algorithm 1. In this section, we use an illustrative example to show how this algorithm identifies a single transition, and to give some intuition why the algorithm satisfies these four properties. In the next section, we prove that our algorithm indeed satisfies these four properties and thus prove that it identifies 1-DTAs efficiently in the limit. Example 2. Suppose that after having identified a few transitions, our algorithm has constructed the (incomplete) 1-DTA A from Figure 2. Furthermore, suppose

746

S. Verwer, M. de Weerdt, and C. Witteveen

a 0x3 reset

q1

a 4x
q0

b 0x


a 10  x 
reset q32

Fig. 2. A partially identified 1-DTA. The transitions from state q0 have been completely identified. State q1 only has one outgoing transition. State q2 has none.

that S contains the following timed strings: {(a, 4)(a, 6), (a, 5)(b, 6), (b, 3)(a, 2), (a, 4)(a, 1)(a, 3), (a, 4)(a, 2)(a, 2)(b, 3)} ⊆ S+ and {(a, 3)(a, 10), (a, 4)(a, 2)(a, 2), (a, 4)(a, 3)(a, 2)(b, 3), (a, 5)(a, 3)} ⊆ S− . Our algorithm has to identify a new transition δ of A using information from S. There are a few possible identifiable transitions: state q1 does not yet contain any transitions with label b, or with label a and valuations smaller than 9, and state q2 does not yet contain any transitions at all. Our algorithm first makes a choice which transition to identify, i.e., it selects the source state, label, and valuations for a new transition. Then our algorithm actually identifies the transition, i.e., it uses S in order to determine the target state, clock guard, and reset of the transition. As can be seen from the example, the first problem our algorithm has to deal with is to determine which transition to identify. Our algorithm makes this decision using a fixed predetermined order (independent of the input sample). The order used by our algorithm is very straightforward: first a state q is selected in the order of identification (first identified first), second a transition label l is selected in alphabetic order, and third the highest possible upper bound c for a clock guard in this state-label combination is chosen. This fixed order makes it easier to prove the existence of characteristic sets (satisfying property 3). In our example, our algorithm will try to identify a transition δ = q, q  , l, c ≤ x ≤ c , r, where q = q1 , l = a, and c = 9 (since there exists a transition with a clock guard that is satisfied by a valuation v = 10) are all fixed. Thus, our algorithm only needs to identify: (i) the target state q  , (ii) the lower bound of the clock guard c, and (iii) the clock reset r. Note that fixing q, a, and c in this way does not influence which transitions will be identified by our algorithm. Since we need to identify a transition with these values anyway, it only influences the order in which these transitions are identified. We now show how our algorithm identifies c, r, and q  . The lower bound c. Our algorithm first identifies the lower bound c of the clock guard g of δ. The smallest possible lower bound for g is the smallest reachable valuation vmin in q (q1 in the example). This valuation vmin is equal to the smallest lower bound of a transition with q as target. In the example, vmin is 4. Thus, the lower bound c has to be a value with the set {c | vmin ≤ c ≤ c }. One approach for finding c would be to try all possible values from this set and pick the best one. However, since time values are encoded in binary in the input sample S, iterating over such a set is exponential in the size of these time values,

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

747

Algorithm 1. Efficiently learning 1-DTAs from polynomial data: ID 1DTA Require: An input sample S = (S+ , S− ) for a language Lt , with alphabet Σ Ensure: A is a 1-DTA consistent with S, i.e. S+ ⊆ L(A) and S− ⊆ L(A)C , in addition, if it holds that Scs ⊆ S, then L(A) = Lt A := Q = {q0 }, x, Σ, Δ = ∅, q0 , F = ∅ if S+ contains the empty timed string λ then set F := {q0 } while there exist a reachable timed state (q, v) and a symbol a for which there exists no transition q, q  , a, g, r ∈ Δ such that v satisfies g do for all states q ∈ Q and symbols a ∈ Σ do vmin := min{v | (q, v) is reachable } c := max{v | ¬∃ q, q  , a, g, r ∈ Δ such that v satisfies g} while vmin ≤ c do create a new transition δ := q, q  := 0, a, g := vmin ≤ x ≤ c , r, add δ to Δ V := {v | ∃τ ∈ S : τ fires δ with valuation v} r := true and c1 := lower bound(δ, V ∪ {vmin }, A, S) r := false and c2 := lower bound(δ, V ∪ {vmin }, A, S) if c1 ≤ c2 then set r := true and g := c1 ≤ x ≤ c else set r := false and g := c2 ≤ x ≤ c for every state q  ∈ Q (first identified first) do q  := q  if consistent(A, S) is true then break else q  := 0 end for if q  = 0 then create a new state q  , set q  := q  , and add q  to Q if ∃τ ∈ S+ such that τ ends in q  then set F := F ∪ {q  } end if c := min{v | v satisfies g} − 1 end while end for end while

i.e., it is exponential in the size of S (contradicting property 1). This is why our algorithm only tries those time values that are actually used by timed strings from S. We determine these in the following way. We first set the lower bound of g to be vmin . There are now examples in S that fire δ. The set of valuations V that these examples use to fire δ are all possible lower bounds for g, i.e., V := {v | ∃τ ∈ S : τ fires δ with valuation v}. In our example, we have that {(a, 4)(a, 1)(a, 3)} ⊆ S+ and {(a, 5)(a, 3), (a, 4)(a, 2)(a, 2)} ⊆ S− . In this case, V = {4 + 1 = 5, 5 + 3 = 8, 4 + 2 = 6}. Since for every time value in V there exists at least one timed string in S for every such time value, iterating over this set is polynomial in the size of S (satisfying property 1). From the set V ∪ {vmin } our algorithm selects the smallest possible consistent lower bound. A lower bound is consistent if the 1-DTA resulting from identifying this bound is consistent with the input sample S. A 1-DTA A is called consistent if S contains no positive example that inevitably ends in the same state as a negative example, i.e., if the result A can still be such that S+ ∈ L(A) and S− ∈ L(A)C (satisfying property 4). Whether A is consistent with S is checked

748

S. Verwer, M. de Weerdt, and C. Witteveen

by testing whether there exist no two timed strings τ ∈ S+ and τ  ∈ S− that reach the same timed state (possibly after making a partial time transition) and afterwards their suffixes are identical. We use consistent to denote this check. This check can clearly be done in polynomial time (satisfying property 1). Our algorithm finds the smallest consistent lower bound by trying every possible lower bound c ∈ V ∪ {vmin }, and testing whether the result is consistent. We use lower bound to denote this routine. This routine ensures that at least one timed string from S will fire δ, and hence that our algorithm only identifies a polynomial amount of transitions (satisfying property 2). In our example, setting c to 5 makes A inconsistent since now both (a, 4)(a, 1)(a, 3) and (a, 4)(a, 2)(a, 2) reach (q  , 6), where q  is any possible target for δ, and afterwards they have the same suffix (a, 2). However, setting c to 6 does not make A inconsistent. Since 6 is the smallest value in V ∪{vmin } greater than 5, c = 6 is the smallest consistent lower bound for g. Our main reason for selecting the smallest consistent lower bound for g is that this selection can be used to force our algorithm to make the correct identification (required by property 3). Suppose that if our algorithm identifies c∗ , and if all other identifications are correct, then the result A will be such that L(A) = Lt . Hence, our algorithm should identify c∗ . In this case, there always exist examples that result in an inconsistency when our algorithm selects any valuation smaller than c∗ . The reason is that an example that fires δ with valuation c∗ − 1 should actually fire a different transition, to a different state, or with a different reset value. Hence, the languages after firing these transitions are different. Therefore, there would exist two timed strings τ ∈ Lt and τ  ∈ LC t (that can be included in S) that have identical suffixes after firing δ with valuations c∗ and c∗ − 1 respectively. Moreover, any pair of string that fire δ with valuations greater or equal to c∗ cannot lead to an inconsistency since their languages after firing δ are the same. The reset r. After having identified the lower bound c of the clock guard g of δ, our algorithm needs to identify the reset r of δ. One may notice that the identification of g depends on whether δ contains a clock reset or not: the value of r determines the valuations that are reached by timed strings after firing δ (the clock can be reset to 0), hence this value determines whether A is consistent after trying a particular lower bound for g. In our example, (a, 4)(a, 1)(a, 3) and (a, 4)(a, 1)(a, 2) reach (q  , 1) and (q  , 0) respectively before their suffixes are identical if r = true. Because of this, our algorithm identifies the clock reset r of δ at the same time it identifies its clock guard g. The method it uses to identify r is very simple: first set r = true and then find the smallest consistent lower bound c1 for g, then set r = false and find another such lower bound c2 for g. The value of r is set to true if and only if the lower bound found with this setting is smaller than the other one, i.e., iff c1 ≤ c2 . There always exist timed strings that ensure that the smallest consistent lower bound for g when the clock reset is set incorrectly is larger than when it is set correctly (satisfying property 3). In our example the timed strings that ensure this are (a, 4)(a, 2)(a, 2)(b, 3) ∈ S+ and (a, 4)(a, 3)(a, 2)(b, 3) ∈ S− . Because these examples reach the same valuations

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

749

in state q  only if the clock is reset, they create an inconsistency when r is set to true. In general, such strings always exists since the difference of 1 time value is sufficient for such an inconsistency: a difference of 1 time value can always be the difference between later satisfying and not satisfying some clock guard.3 The target state q  . Having identified both the clock guard and the reset of δ, our algorithm still needs to identify the target state q  of δ. Since we need to make sure that our algorithm is capable of identifying any possible transition (required by property 3), we need to try all possible settings for q  , and in order to make it easier to prove the existence of a characteristic set (required by property 3), we do so in a fixed order. The order our algorithm uses is the order in which our algorithm identified the states, i.e., first q0 , then the first additional identified state, then the second, and so on. The target state for δ is set to be the first consistent target state in this order. In our example, we just try state q0 , then state q1 , and finally state q3 . When none of the currently identified states result in a consistent 1-DTA A, the target is set to be a new state. This new state is set to be a final state only if there exists a timed string in S+ that ends in it. It should be clear that since the languages after reaching different states are different, there always exist timed strings that ensure that our algorithm identifies the correct target (satisfying property 3). In our example, there exist no timed strings that make A inconsistent when our algorithm tries the first state (state q0 ), and hence our algorithm identifies a transition q1 , q0 , a, 6 ≤ x ≤ 9, false. This completes the identification of δ and (possibly) q  . This identification of a single transition δ essentially describes the main part of our algorithm (see Algorithm 1). However, we still have to explain how our algorithm iterates over the transitions it identifies. The algorithm consists of a main loop that iterates in a fixed order over the possible source states and labels for new transitions. For every combination of a source state q and a label a, our algorithm first sets two values: vmin and c . The first is the smallest reachable valuation in q. The second is the fixed upper bound of the delay guard of a new transition. Because our model is deterministic, this is set to be the largest reachable valuation for which there exists no transition with q as source state and a as label. After identifying a transition δ with these values, our algorithm updates c to be one less than the lower bound of the clock guard of δ. If c is still greater than vmin , there are still transitions to identify for state q and label a. Thus, our algorithm iterates and continues this iteration until c is strictly less than vmin . Our main reason for adding this additional iteration is that it makes it easier to prove the convergence of our algorithm (property 4). The main loop of our algorithm continuously identifies new transitions and possibly new target states until there are no more new transitions to identify, i.e., until there exists a transition for every reachable timed state in A. This is necessary because identifying a transition δ can create new identifiable transitions. This happens when the smallest reachable 3

This holds unless the clock guard can only be satisfied by a single valuation v, i.e., unless g = c ≤ x ≤ c. However, in this case any setting for r is correct since both can lead to results such that L(A) − Lt .

750

S. Verwer, M. de Weerdt, and C. Witteveen

valuation vmin in some state is decreased, or when a new state is identified, by the identification of δ.

5

Properties of the Algorithm

We described an algorithm for the identification of 1-DTAs. We claim now, and argued in the previous section, that the algorithm converges efficiently to a correct 1-DTA, i.e., that it identifies 1-DTAs efficiently in the limit. In this section, we show that the four properties mentioned in the previous section hold. The combination of these properties satisfies all the constraints required for efficient identification in the limit (Definition 4), and hence shows that 1DTAs are efficiently identifiable (Theorem 1). We only give sketches of proofs due to space restrictions. Proposition 1. ID 1DTA is a polynomial time algorithm (properties 1 and 2). Proof. (sketch) Identifying a single transition can be done in polynomial time as argued in the previous section. In addition, every transition is guaranteed to be fired by at least one timed string from S. Hence, our algorithm will stop after identifying a polynomial amount of transitions. The proposition follows.   Lemma 1. There exist polynomial characteristic sets of the transitions of 1 DTAs for ID 1DTA (property 3). Proof. (sketch) As shown by the example in the previous section, we can always find a polynomial amount of timed strings such that our algorithm identifies the correct transition δ. In addition, we can bound each of these strings by a polynomial since 1-DTAs are polynomially distinguishable. Moreover, because the order in which our algorithm identifies transitions is independent of S, it is impossible to add additional examples to S such that our algorithm will no longer identify δ. This proves the lemma.   Lemma 2. ID 1DTA converges after identifying a polynomial amount of transitions (property 4). Proof. (sketch) Since 1-DTAs are polynomially distinguishable, any state can be reached by timed strings τ of polynomial length. Hence, the main loop will be run at most |τ | times before the smallest reachable valuation in any state of At can be reached. Once the smallest reachable valuation can be reached, every transition can be identified. In a single run of the main loop, at most |At | new correct transitions can be identified. Thus, our algorithm identifies at most |τ | × |At | transitions before every transition can be identified. Hence, by Lemma 1, every transition of At can be identified correctly after identifying |τ | × |At | transitions.   Theorem 1. 1-DTAs are efficiently identifiable in the limit. Proof. By Proposition 1 and Lemma 2, if all the examples from Lemma 1 are included in S, our algorithm returns a 1-DTA A such that L(A) = Lt in polynomial time and from polynomial data. We conclude that Algorithm 1 identifies 1-DTAs efficiently in the limit.  

One-Clock Deterministic TA Are Efficiently Identifiable in the Limit

6

751

Conclusions

In this paper we described an algorithm that identifies 1-DTAs efficient in the limit. This algorithm is an important step in the direction of being able to identify timed systems efficiently. To the best of our knowledge, our result is the first positive efficiency result for identifying timed automata. The fact that 1-DTAs can be identified efficiently has important consequences for anyone interested in identifying timed systems. Most importantly, it is a reason to model timed systems with 1-DTAs. However, when 1-DTAs are too restrictive, our result is still useful because identification algorithms for other DTAs could identify the class of 1-DTAs efficiently. This is a desirable property since 1-DTAs are efficiently identifiable. For instance, in related work, a query learning algorithm is described for identifying event recording automata (ERAs) [9]. However, the used query learning algorithm requires an exponential amount of queries (data). It would be interesting to either adapt the timed query learning algorithm to the class of 1-DTAs, or to show that the algorithm does in fact identify 1-DTAs efficiently. This could result in an efficient query learning algorithm for timed systems.

References 1. Alur, R., Dill, D.L.: A theory of timed automata. Theoretical Computer Science 126, 183–235 (1994) 2. Larsen, K.G., Petterson, P., Yi, W.: Uppaal in a nutschell. International journal on software tools for technology transfer 1(1-2), 134–152 (1997) 3. Gold, E.M.: Complexity of automaton identification from given data. Information and Control 37(3), 302–320 (1978) 4. Pitt, L., Warmuth, M.: The minimum consistent dfa problem cannot be approximated within and polynomial. In: Annual ACM Symposium on Theory of Computing, pp. 421–432. ACM, New York (1989) 5. Gold, E.M.: Language identification in the limit. Information and Control 10(5), 447–474 (1967) 6. Oncina, J., Garcia, P.: Inferring regular languages in polynomial update time. In: Pattern Recognition and Image Analysis. Series in Machine Perception and Artificial Intelligence, vol. 1, pp. 49–61. World Scientific, Singapore (1992) 7. de la Higuera, C.: Characteristic sets for polynomial grammatical inference. Machine Learning 27(2), 125–138 (1997) 8. Verwer, S., de Weerdt, M., Witteveen, C.: Polynomial distinguishability of timed automata. In: Clark, A., Coste, F., Miclet, L. (eds.) ICGI 2008. LNCS, vol. 5278, pp. 238–251. Springer, Heidelberg (2008) 9. Grinchtein, O., Jonsson, B., Pettersson, P.: Inference of event-recording automata using timed decision trees. In: Baier, C., Hermanns, H. (eds.) CONCUR 2006. LNCS, vol. 4137, pp. 435–449. Springer, Heidelberg (2006)

Author Index

Abdulla, Parosh Aziz Afonin, Sergey 83 Akama, Yohji 93 Allen, Emily 176

71

Glaßer, Christian 374 Gnaedig, Isabelle 386 Golomazov, Denis 83 Grabowski, Szymon 338

Baader, Franz 105 Bailly, Rapha¨el 117 Balbach, Frank J. 1 Bannai, Hideo 422, 578 Bauer, Andreas 105 Behle, Christoph 129 Berg, Tobias 141 Berry, Vincent 702 Bertrand, Nathalie 152 Beyersdorff, Olaf 164 Blanchet-Sadri, Francine 176, 188 Boigelot, Bernard 200 Bollig, Beate 212 Bonizzoni, Paola 224 Bordihn, Henning 236 Brzozowski, Janusz 247 Bucci, Michelangelo 259 B¨ uchse, Matthias 267 Byrum, Cameron 176 Carle, Benjamin 279 Caron, Pascal 290 Cattaneo, Gianpiero 302 Champarnaud, Jean-Marc Clarridge, Adam 314 Courcelle, Bruno 19 Dassow, J¨ urgen 326 Degbomont, Jean-Fran¸cois De Luca, Alessandro 259 Delzanno, Giorgio 71 Denis, Fran¸cois 117 de Weerdt, Mathijs 740 Dennunzio, Alberto 302 Ferretti, Claudio 224 Formenti, Enrico 302 Fredriksson, Kimmo 338 Gauwin, Olivier 350 Gierasimczuk, Nina 362

290

200

Han, Yo-Sub 398 Hashimoto, Takashi 614 Hemerik, Kees 410 Hempel, Harald 141 Holan, Tom´ aˇs 542 Holzer, Markus 23, 236 I, Tomohiro 422 Inenaga, Shunsuke Ito, Masami 434

422

Jacquemard, Florent 446 Jain, Sanjay 43 Jir´ askov´ a, Galina 458 Kasprzik, Anna 469 Klay, Francis 446 K¨ obler, Johannes 164 Krebs, Andreas 129 Kusano, Kazuhiko 578 Kutrib, Martin 23, 236 Leupold, Peter 434 Liefooghe, Aude 481 Limaye, Nutan 493 Lisitsa, Alexei 505 Liu, Jiamou 518 Llull-Chavarr´ıa, Jordi 530 Lopatkov´ a, Mark´eta 542 Mahajan, Meena 493 Masopust, Tom´ aˇs 554 Matoba, Ryuichi 566 Matsubara, Wataru 578 Mauri, Giancarlo 224 Merca¸s, Robert 176, 188 Mignot, Ludovic 290 Minnes, Mia 518 Mitrana, Victor 434, 588 Moore, Neil 601 M¨ uller, Sebastian 164

754

Author Index

Nakamura, Makoto 566, 614 Narendran, Paliath 279 Nicaud, Cyril 626 Niehren, Joachim 350

Scornavacca, Celine 702 Shallit, Jeffrey 247 Shinohara, Ayumi 578 St¨ uber, Torsten 267 Straßburger, Lutz 715 Suman, P. Vijay 728

Ollinger, Nicolas 638 Onodera, Kaoru 648 Otto, Friedrich 660

Takeda, Masayuki 422 Tison, Sophie 350 Tiu, Alwen 105 Tojo, Satoshi 566, 614 Touzet, H´el`ene 481 Travers, Stephen 374 Truthe, Bianca 588 Turaev, Sherzod 326

Pandya, Paritosh K. 728 Pardubsk´ a, Dana 660 Pavan, A. 374 Pighizzini, Giovanni 458 Pinchinat, Sophie 152 Pl´ atek, Martin 660 Potapov, Igor 505 Pribavkina, Elena V. 672 Provillard, Julien 302 Raclet, Jean-Baptiste 152 Ranwez, Vincent 702 Rashin, Abraham 188 Reifferscheid, Stephanie 129 Rodaro, Emanuele 672 Roman, Adam 684 Roslin Sagaya Mary, Anthonath Saleh, Rafiq 505 Salimov, Paul V. 696 Salomaa, Kai 59, 314, 398

Vacher, Camille 446 Valero, Oscar 530 Van Begin, Laurent 71 Varr´e, Jean-St´ephane 481 Verwer, Sicco 740 Willett, Elara 188 Witteveen, Cees 740 224

Xu, Zhi Yu, Sheng

247 398

Zeugmann, Thomas

1