Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 26 views

    Untitleddocument

    Uploaded by

    yayatstukarl
    1) NFA generation compiles a regular expression into a nondeterministic finite automaton (NFA) by traversing the syntax tree. This translation is linear in the size of the expression: O(|r|). 2) Determinization transforms the NFA into a deterministic finite automaton (DFA) using subset construction. 3) Minimization merges equivalent states to reduce the size of the DFA. The resulting DFA permits linear-time string recognition: O(n), but its worst-case size is exponential in the regular expression size: O(2^|r|).

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd

    Untitleddocument

    Uploaded by

    yayatstukarl
    26 views3 pages
    1) NFA generation compiles a regular expression into a nondeterministic finite automaton (NFA) by traversing the syntax tree. This translation is linear in the size of the expression: O(|r|). 2) Determinization transforms the NFA into a deterministic finite automaton (DFA) using subset construction. 3) Minimization merges equivalent states to reduce the size of the DFA. The resulting DFA permits linear-time string recognition: O(n), but its worst-case size is exponential in the regular expression size: O(2^|r|).

    Original Title

    Untitleddocument(4)

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    DOC, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    1) NFA generation compiles a regular expression into a nondeterministic finite automaton (NFA) by traversing the syntax tree. This translation is linear in the size of the expression: O(|r|). 2) Determinization transforms the NFA into a deterministic finite automaton (DFA) using subset construction. 3) Minimization merges equivalent states to reduce the size of the DFA. The resulting DFA permits linear-time string recognition: O(n), but its worst-case size is exponential in the regular expression size: O(2^|r|).

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    26 views3 pages

    Untitleddocument

    Uploaded by

    yayatstukarl
    1) NFA generation compiles a regular expression into a nondeterministic finite automaton (NFA) by traversing the syntax tree. This translation is linear in the size of the expression: O(|r|). 2) Determinization transforms the NFA into a deterministic finite automaton (DFA) using subset construction. 3) Minimization merges equivalent states to reduce the size of the DFA. The resulting DFA permits linear-time string recognition: O(n), but its worst-case size is exponential in the regular expression size: O(2^|r|).

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    of 3

    Comlexity on Generating Regular Expression to NFA

    A Nondeterministic Finite-state Automaton (NFA) is a tuple (Q,S,q0,F,d) where

    * Q, a finite set of states


    * S, a finite set of input symbols
    * q0 : Q, the start state
    * F < Q, the set of final states
    * d : Q x S' -> P(Q), transition function (S' = S U {eps})

    1) NFA generation. Compile the expression into an NFA, using transitions with the epsilon
    symbol e. (Book 3.7.4). This translation is compositional: simply traverse the syntax tree of the
    regular expression. The size of the automaton is linear in the size of the expression: O(|r|).

    But NFAs are, in comparison to DFAs, - more difficult to implement - less efficient to run: O(|r| *
    n), where n is the input length.

    (http://www.cse.chalmers.se/edu/course/TIN321/lectures/proglang-05.html)

    In contrast, Thompson's algorithm maintains state lists of length approximately n and processes
    the string, also of length n, for a total of O(n2) time. (The run time is superlinear, because we
    are not keeping the regular expression constant as the input grows. For a regular expression of
    length m run on text of length n, the Thompson NFA requires O(mn) time.)
    A Nondeterministic Finite-state Automaton (NFA) is a tuple (Q,S,q0,F,d) where

    * Q, a finite set of states


    * S, a finite set of input symbols
    * q0 : Q, the start state
    * F < Q, the set of final states
    * d : Q x S' -> P(Q), transition function (S' = S U {eps})

    http://www.cse.chalmers.se/edu/course/TIN321/lectures/proglang-05.html

    Finite-state automata

    A Nondeterministic Finite-state Automaton (NFA) is a tuple (Q,S,q0,F,d) where

    * Q, a finite set of states


    * S, a finite set of input symbols
    * q0 : Q, the start state
    * F < Q, the set of final states
    * d : Q x S' -> P(Q), transition function (S' = S U {eps})

    A Deterministic Finite-state Automaton (DFA) is like NFA. except that the value of the transition
    function d is a single state in Q (instead of a subset of Q) and there are no epsilon transitions
    (transitions that don't consume a symbol). In other words,

    * d : Q x S -> Q, transition function

    It is customary to draw diagrams with circles for states and arrows for the transition function:
    you can find them in the course book, and we will draw them on the blackboard.

    Compiling regular expressions into finite-state automata

    1) NFA generation. Compile the expression into an NFA, using transitions with the epsilon
    symbol e. (Book 3.7.4). This translation is compositional: simply traverse the syntax tree of the
    regular expression. The size of the automaton is linear in the size of the expression: O(|r|).

    But NFAs are, in comparison to DFAs, - more difficult to implement - less efficient to run: O(|r| *
    n), where n is the input length.
    2) Determinization. Transform the NFA into a DFA. (Book 3.7.1). Here you go through states,
    and for each symbol create a state collecting those states that the symbol can lead to (subset
    construction).

    The DFA can still be bigger than necessary, i.e. have more states than needed.

    3) Minimization. Merge equivalent states (Book 3.9.6): states beginning from which the
    automaton recognizes the same set of strings.

    The resulting DFA permits analysis that is linear in the length of the input string: O (n). But its
    size is still exponential, at worst, in the length of the regular expression: O (2^|r|).

    You might also like