Synthesis of hierarchical systems

In automated synthesis, given a specification, we automatically create a system that is guaranteed to satisfy the specification. In the classical temporal synthesis algorithms, one usually creates a ''flat'' system ''from scratch''. However, real-life software and hardware systems are usually created using preexisting libraries of reusable components, and are not ''flat'' since repeated sub-systems are described only once. In this work we describe an algorithm for the synthesis of a hierarchical system from a library of hierarchical components, which follows the ''bottom-up'' approach to system design. Our algorithm works by synthesizing in many rounds, when at each round the system designer provides the specification of the currently desired module, which is then automatically synthesized using the initial library and the previously constructed modules. To ensure that the synthesized module actually takes advantage of the available high-level modules, we guide the algorithm by enforcing certain modularity criteria. We show that the synthesis of a hierarchical system from a library of hierarchical components is Exptime-complete for @m-calculus, and 2Exptime-complete for Ltl, both in the cases of complete and incomplete information. Thus, in all cases, it is not harder than the classical synthesis problem (of synthesizing flat systems ''from scratch''), even though the synthesized hierarchical system may be exponentially smaller than a flat one.

[1]  Amir Pnueli,et al.  On the synthesis of a reactive module , 1989, POPL '89.

[2]  Fabio Somenzi,et al.  Safety first: a two-stage algorithm for the synthesis of reactive systems , 2012, International Journal on Software Tools for Technology Transfer.

[3]  Tiziano Villa,et al.  VIS: A System for Verification and Synthesis , 1996, CAV.

[4]  Dana Fisman,et al.  Reasoning with Temporal Logic on Truncated Paths , 2003, CAV.

[5]  Colin Stirling,et al.  Modal mu-calculi , 2007, Handbook of Modal Logic.

[6]  Pierre Wolper,et al.  An automata-theoretic approach to branching-time model checking , 2000, JACM.

[7]  Aniello Murano,et al.  The Complexity of Enriched Mu-Calculi , 2008, Log. Methods Comput. Sci..

[8]  Yoad Lustig,et al.  Synthesis from Component Libraries , 2009, FoSSaCS.

[9]  Amir Pnueli,et al.  Synthesis of Reactive(1) Designs , 2006, VMCAI.

[10]  Amir Pnueli,et al.  The temporal logic of programs , 1977, 18th Annual Symposium on Foundations of Computer Science (sfcs 1977).

[11]  Alonzo Church,et al.  Logic, arithmetic, and automata , 1962 .

[12]  Neil Immerman,et al.  First-Order and Temporal Logics for Nested Words , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[13]  Rajeev Alur,et al.  Model checking of hierarchical state machines , 1998, TOPL.

[14]  Yoad Lustig,et al.  Synthesis from Recursive-Components Libraries , 2011, GandALF.

[15]  Amihood Amir,et al.  Combinatorial Pattern Matching (CPM 2010) , 2012, Inf. Comput..

[16]  Aniello Murano,et al.  Pushdown module checking , 2010, Formal Methods Syst. Des..

[17]  Giuseppe De Giacomo,et al.  Automatic Synthesis of New Behaviors from a Library of Available Behaviors , 2007, IJCAI.

[18]  Andrea Maggiolo-Schettini,et al.  Structural Model Checking for Communicating Hierarchical Machines , 2004, MFCS.

[19]  Swarat Chaudhuri,et al.  On-the-Fly Reachability and Cycle Detection for Recursive State Machines , 2005, TACAS.

[20]  Zohar Manna,et al.  A Deductive Approach to Program Synthesis , 1979, TOPL.

[21]  E. Allen Emerson,et al.  An Automata Theoretic Decision Procedure for the Propositional Mu-Calculus , 1989, Inf. Comput..

[22]  David Janin,et al.  Automata for the mu-calculus and Related Results , 1995 .

[23]  Aniello Murano,et al.  Improved model checking of hierarchical systems , 2010, Inf. Comput..

[24]  Rüdiger Ehlers,et al.  Unbeast: Symbolic Bounded Synthesis , 2011, TACAS.

[25]  Aniello Murano,et al.  Pushdown module checking with imperfect information , 2007, Inf. Comput..

[26]  Joseph Sifakis,et al.  A Notion of Glue Expressiveness for Component-Based Systems , 2008, CONCUR.

[27]  Véronique Bruyère,et al.  Acacia+, a Tool for LTL Synthesis , 2012, CAV.

[28]  Joseph Sifakis,et al.  Synthesizing Glue Operators from Glue Constraints for the Construction of Component-Based Systems , 2011, SC@TOOLS.

[29]  E. Allen Emerson,et al.  Tree automata, mu-calculus and determinacy , 1991, [1991] Proceedings 32nd Annual Symposium of Foundations of Computer Science.

[30]  Pierre-Yves Schobbens,et al.  Synthesising Features by Games , 2005, AVoCS.

[31]  Thomas Wilke,et al.  Alternating tree automata, parity games, and modal {$\mu$}-calculus , 2001 .

[32]  Orna Kupfermant,et al.  Synthesis with Incomplete Informatio , 2000 .

[33]  M. Rabin Weakly Definable Relations and Special Automata , 1970 .

[34]  Fred Kröger,et al.  Temporal Logic of Programs , 1987, EATCS Monographs on Theoretical Computer Science.

[35]  Gustavo Alonso,et al.  Web Services: Concepts, Architectures and Applications , 2009 .

[36]  Edmund M. Clarke,et al.  Using Branching Time Temporal Logic to Synthesize Synchronization Skeletons , 1982, Sci. Comput. Program..

[37]  Joseph Sifakis A framework for component-based construction , 2005, Third IEEE International Conference on Software Engineering and Formal Methods (SEFM'05).

[38]  Markus Lohrey,et al.  Fixpoint Logics on Hierarchical Structures , 2005, FSTTCS.

[39]  Amir Pnueli,et al.  On the Development of Reactive Systems , 1989, Logics and Models of Concurrent Systems.

[40]  Gary T. Leavens Modular specification and verification of object-oriented programs , 1991, IEEE Software.

[41]  Orna Kupferman,et al.  µ-Calculus Synthesis , 2000, MFCS.

[42]  Thomas A. Henzinger,et al.  INTERFACE-BASED DESIGN , 2005 .

[43]  Giuseppe De Giacomo,et al.  Automatic behavior composition synthesis , 2013, Artif. Intell..

[44]  E. Allen Emerson,et al.  Temporal and Modal Logic , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[45]  Rajeev Alur,et al.  Analysis of recursive state machines , 2001, TOPL.

[46]  Igor Walukiewicz,et al.  Automata for the Modal mu-Calculus and related Results , 1995, MFCS.

[47]  Yoad Lustig,et al.  Synthesis from component libraries , 2009, International Journal on Software Tools for Technology Transfer.

[48]  David E. Muller,et al.  Alternating Automata on Infinite Trees , 1987, Theor. Comput. Sci..

[49]  C. Pixley,et al.  Formal verification of commercial integrated circuits , 2001 .

[50]  Swarat Chaudhuri,et al.  A fixpoint calculus for local and global program flows , 2006, POPL '06.

[51]  Dexter Kozen,et al.  Results on the Propositional µ-Calculus , 1982, ICALP.

[52]  E. Muller David,et al.  Alternating automata on infinite trees , 1987 .

[53]  Diego Calvanese,et al.  Automatic Service Composition and Synthesis: the Roman Model , 2008, IEEE Data Eng. Bull..

[54]  Axel Legay,et al.  µ-calculus Pushdown Module Checking with Imperfect State Information , 2008, IFIP TCS.

[55]  Kavita Ravi,et al.  A Hybrid Algorithm for LTL Games , 2008, VMCAI.