Results 1 
5 of
5
Optimal Lower bounds on Regular Expression Size using Communication Complexity
 In: Proceedings of FoSSaCS: 273–286, LNCS 4962
, 2008
"... Abstract. The problem of converting deterministic finite automata into (short) regular expressions is considered. It is known that the required expression size is 2 Θ(n) in the worst case for infinite languages, and for finite languages it is n Ω(log log n) and n O(log n) , if the alphabet size grow ..."
Abstract

Cited by 10 (7 self)
 Add to MetaCart
Abstract. The problem of converting deterministic finite automata into (short) regular expressions is considered. It is known that the required expression size is 2 Θ(n) in the worst case for infinite languages, and for finite languages it is n Ω(log log n) and n O(log n) , if the alphabet size grows with the number of states n of the given automaton. A new lower bound method based on communication complexity for regular expression size is developed to show that the required size is indeed n Θ(log n). For constant alphabet size the best lower bound known to date is Ω(n 2), even when allowing infinite languages and nondeterministic finite automata. As the technique developed here works equally well for deterministic finite automata over binary alphabets, the lower bound is improved to n Ω(log n). 1
Using hammock graphs to structure programs
 IEEE TRANSACTIONS ON SOFTWARE ENGINEERING
, 2004
"... Advanced computer architectures rely mainly on compiler optimizations for parallelization, vectorization, and pipelining. Efficient code generation is based on a control dependence analysis to find the basic blocks and to determine the regions of control. However, unstructured branch statements, suc ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
Advanced computer architectures rely mainly on compiler optimizations for parallelization, vectorization, and pipelining. Efficient code generation is based on a control dependence analysis to find the basic blocks and to determine the regions of control. However, unstructured branch statements, such as jumps and goto’s, render the control flow analysis difficult, timeconsuming, and result in poor code generation. Branches are part of many programming languages and occur in legacy and maintenance code as well as in assembler, intermediate languages, and byte code. A simple and effective technique is presented to convert unstructured branches into hammock graph control structures. Using three basic transformations, an equivalent program is obtained in which all control statements have a welldefined scope. In the interest of predication and branch prediction, the number of control variables has been minimized, thereby allowing a limited code replication. The correctness of the transformations has been proven using an axiomatic proof rule system. With respect to previous work, the algorithm is simpler and the branch conditions are less complex, making the program more readable and the code generation more efficient. Additionally, hammock graphs define single entry single exit regions and therefore allow localized optimizations. The restructuring method has been implemented into the parallelizing compiler FPT and allows to extract parallelism in unstructured programs. The use of hammock graph transformations in other application areas such as vectorization, decompilation, and assembly program restructuring is also demonstrated.
MODELDRIVEN INTEGRATION OF SOFTWARE AND SERVICE COMPONENTS
, 2006
"... Building applications by composing predeveloped components has much promise for reuse and software engineering industrialization. Expressing integration requirements in a model and its supporting tools not only elevates the abstraction of the development and automates reoccurring lowlevel integrat ..."
Abstract
 Add to MetaCart
Building applications by composing predeveloped components has much promise for reuse and software engineering industrialization. Expressing integration requirements in a model and its supporting tools not only elevates the abstraction of the development and automates reoccurring lowlevel integration code, but also leverages the integration tools for various supporting functionality such as analysis, transformation, simulation, optimization, and monitoring. This dissertation addresses integration of components using two modeldriven approaches. 1. There is an ongoing demand and trend of exposing software applications as IT services and utilities. We first discuss a modeldriven approach to integration of service components. The integration requirements are depicted as a domain neutral graphical process model in a Business Process Management (BPM) server. A transformation framework, called Regular Expression Language (REL), is offered which transforms graphical business process models to Business Process Execution Language (BPEL). The theoretical and technical difficulty of transforming a
The Böhm–Jacopini Theorem is False, Propositionally
"... Abstract. The Böhm–Jacopini theorem (Böhm and Jacopini, 1966) is a classical result of program schematology. It states that any deterministic flowchart program is equivalent to a while program. The theorem is usually formulated at the firstorder interpreted or firstorder uninterpreted (schematic) ..."
Abstract
 Add to MetaCart
Abstract. The Böhm–Jacopini theorem (Böhm and Jacopini, 1966) is a classical result of program schematology. It states that any deterministic flowchart program is equivalent to a while program. The theorem is usually formulated at the firstorder interpreted or firstorder uninterpreted (schematic) level, because the construction requires the introduction of auxiliary variables. Ashcroft and Manna (1972) and Kosaraju (1973) showed that this is unavoidable. As observed by a number of authors, a slightly more powerful structured programming construct, namely loop programs with multilevel breaks, is sufficient to represent all deterministic flowcharts without introducing auxiliary variables. Kosaraju (1973) established a strict hierarchy determined by the maximum depth of nesting allowed. In this paper we give a purely propositional account of these results. We reformulate the problems at the propositional level in terms of automata on guarded strings, the automatatheoretic counterpart to Kleene algebra with tests. Whereas the classical approaches do not distinguish between firstorder and propositional levels of abstraction, we find that the purely propositional formulation allows a more streamlined mathematical treatment, using algebraic and topological concepts such as bisimulation and coinduction. Using these tools, we can give more mathematically rigorous formulations and simpler and more revealing proofs. 1