Wojciech Fraczak

LINEAR-TIME PRIME DECOMPOSITION OF REGULAR PREFIX CODES

One of the new approaches to data classification uses prefix codes and finite state automata as representations of prefix codes. A prefix code is a (possibly infinite) set of strings such that no string is a prefix of another one. An important task driven by the need for the efficient storage of such automata in memory is the decomposition (in the sense of formal languages concatenation) of prefix codes into prime factors. We investigate properties of such prefix code decompositions. A prime decomposition is a decomposition of a prefix code into a concatenation of nontrivial prime prefix codes. A prefix code is prime if it cannot be decomposed into at least two nontrivial prefix codes. In the paper a linear time algorithm is designed which finds the prime decomposition F1F2…Fk of a regular prefix code F given by its minimal deterministic automaton. Our results are especially interesting for infinite regular prefix codes.

Prime normal form and equivalence of simple grammars

A prefix-free language is prime if it cannot be decomposed into a concatenation of two prefix-free languages. We show that we can check in polynomial time if a language generated by a simple context-free grammar is prime. Our algorithm computes a canonical representation of a simple language, converting its arbitrary simple grammar into prime normal form (PNF); a simple grammar is in PNF if all its nonterminals define primes. We also improve the complexity of testing the equivalence of simple grammars. The best previously known algorithm for this problem worked in O(n13) time. We improve it to O(n7 log2 n) and O(n5 polylog v) time, where n is the total size of the grammars involved, and v is the length of a shortest string derivable from a nonterminal, maximized over all nonterminals.

Concatenation state machines and simple functions

We introduce a class of deterministic push-down transducers called concatenation state machines (CSM), and we study its semantic domain which is a class of partial mappings over finitely generated free monoids, called simple functions.

Prime decompositions of regular prefix codes

One of the new approaches to data classification uses finite state automata for representation of prefix codes. An important task driven by the need for the efficient storage of such automata in memory is the decomposition of prefix codes into prime factors. We investigate properties of such prefix code decompositions. A linear time algorithm is designed which finds the prime decomposition <i>F</i><inf>1</inf><i>F</i><inf>2</inf>... <i>F<inf>k</inf></i> of a regular prefix code <i>F</i> given by its minimal deterministic automaton.

Disjoint Set Forest Digraph Representation for an Efficient Dominator Tree Construction

We consider a non-orthodox representation of directed graphs which uses the “disjoint set forest” data structure. We show how such a representation can be used in order to efficiently find the dominator tree. Even though the performance of our algorithm does not improve over the already known algorithms for constructing the dominator tree, the approach is new and it gives place to a highly structured and simple to follow proof of correctness.

A Criterion for Speed Evaluation of Content Inspection Engines

The growing needs of network security and contentaware networking increasingly introduce content processing into the network devices as opposed to the network endpoints. The component of a network device responsible for content inspection is called Content Inspection Engine (CIE). As other components of a network device, the CIE needs to operate at wire-speed, posing a need to look for an appropriate speed-evaluation criterion for CIEs. For processes with constant or at most well-bounded per-packet analyzes (e.g., routing, multi-field packet classification), and processes with flat per-byte processing time (e.g., checksum calculation, encryption/decryption), operation speed is traditionally evaluated in terms of the number of packets or bits processed per second. Such metrics cannot be used for processes in which the processing time of a packet varies widely, depending on its content. We propose to define worst-case throughput as a criterion for evaluating the wire-speed processing capabilities of CIEs. We argue that one may build simple model of a CIE, whether hardware or software based, in the form of a directed graph with edges annotated by the length and processing time of the segments of input data. It is then possible to transform the problem of finding the worst-case throughput of a CIE to the minimum cost to time ratio problem, for which many efficient algorithms exist.

Equivalence of functions represented by simple context-free grammars with output

A partial function F:Σ∗→Ω∗ is called a simple function if F(w) ∈Ω* is the output produced in the generation of a word w ∈Σ* from a nonterminal of a simple context free grammar G with output alphabet Ω. In this paper we present an efficient algorithm for testing equivalence of simple functions. Such functions correspond also to one-state deterministic pushdown transducers. Our algorithm works in time polynomial with respect to |G|+ v(G), where |G| is the size of the textual description of G, and v(G) is the maximum of the shortest lengths of words generated by nonterminals of G.

Decidable Containment Problems of Rational Word Relations

We study a particular case of the inclusion problem for rational relations over words. The problem consists in checking whether a submonoid, M, is included in a rational relation, R. We show that if M is rational and commutative then the problem M ⊆ R is decidable. In the second part of the paper we study the inclusion problem, M ⊆ ↓R, where M is a commutative submonoid and ↓R is the prefix-closure of a rational word relation R. We describe an algorithm which solves the problem in a polynomial time, assuming that the number of tapes (arity of the word relation) is constant.

Computing the throughput of Concatenation State Machines

Concatenation State Machine (CSM) is a labeled directed And-Or graph representing a deterministic push-down transducer. In the high-performance version of CSM, labels associated to edges are words (rather than letters) over the input alphabet. The throughput of a path p is defined as the sum of the lengths of the labels of the path, divided by the number of edges of p. The throughput of a CSM M is defined as the infimum of the throughput of all accepting paths of M. In this paper we give an O(nmlog(max-min@e)) algorithm, computing an @e-approximation of the throughput of a CSM M, where n is the number of nodes, m is the number of edges, and max (min) is the maximum (respectively, minimum) of the lengths of the edge labels of M. While we have been interested in a particular case of an And-Or graph representing a transducer, we have actually solved the following problem: if a real weight function is defined on the edges of an And-Or graph G, we compute an @e-approximation of the infimum of the complete hyper-path mean weights of G. This problem, if restricted to digraphs, is strongly connected to the problem of finding the minimum cycle mean.

REDUCING SIMPLE GRAMMARS: EXPONENTIAL AGAINST HIGHLY-POLYNOMIAL TIME IN PRACTICE

Simple grammar reduction is an important component in the implementation of Concatenation State Machines (a hardware version of stateless push-down automata designed for wire-speed network packet classification). We present a comparison and experimental analysis of the best-known algorithms for grammar reduction. There are two approaches to this problem: one processing compressed strings without decompression and another one which processes strings explicitly. It turns out that the second approach is more efficient in the considered practical scenario despite having worst-case exponential time complexity (while the first one is polynomial). The study has been conducted in the context of network packet classification, where simple grammars are used for representing the classification policies.