1 / 34

Regular Languages and Expressions

Regular Languages and Expressions. Surinder Kumar Jain, University of Sydney. Regular Languages & Expressions. Automaton DFA NFA Ε - NFA CFG as a DFA Equivalence Minimal DFA Expressions Definition Conversion from/to Automaton Regular Langauges

soo
Download Presentation

Regular Languages and Expressions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. RegularLanguages and Expressions Surinder Kumar Jain, University of Sydney

  2. Regular Languages & Expressions • Automaton • DFA • NFA • Ε-NFA • CFG as a DFA • Equivalence • Minimal DFA • Expressions • Definition • Conversion from/to Automaton • Regular Langauges • Pumping Lemma – proving regularness • Closures • Equivalence

  3. Deterministic Finite Automaton • A system with many states • Can transition from one state to another • Usually caused by external input • Set of states is finite • System is in one state at any given time

  4. DFA • Mathematical Definition of a DFA • A = (Q, Σ,δ, q0,F) • Q : States, DFA is in one of these finite states at any time. • Σ : Input symbols, DFA changes its state from one state to another state on consuming an input symbol. • δ : Transition function. • Given a state and an input symbols, gives the next DFA state • Function over QxΣ -> Q. • q0 : Initial DFA state • F : Accepting states. Once DFA reaches one of these states, it may not accept any more input symbols.

  5. DFA Example Q = { waiting, pending, rejected, approved, paid } Σ = {receive, reject, accept, pay } δ : (waiting -> receive -> pending), (pending -> reject -> rejected), (pending -> accept -> accepted), (accepted -> pay -> paid) q0 : {waiting} F : { rejected, paid }

  6. Transition Diagrams start receive accept Accepted pay Waiting Pending Paid Paid reject Paid Rejected Q = { waiting, pending, rejected, approved, paid } Σ = {receive, reject, accept, pay } δ : (waiting -> receive -> pending), (pending -> reject -> rejected), (pending -> accept -> accepted), (accepted -> pay -> paid) q0 : {waiting} F : { rejected, paid }

  7. Language • Set of alphabets • Concatenation (joining) • Strings • A subset of strings is a language • A DFA defines a language • Alphabet set is the set of input symbols • Concatenation - one symbol follows another • Acceptance – sequence of symbols takes DFA from start state to one of the accepting states

  8. Non-deterministic Finite Automaton (DFA) • Five-tuple like a DFA, (Q, Σ,δ, q0,F) • Transition function returns a set not one state • Several outgoing arcs with same symbol • In several states at the same time • Language of NFA

  9. Equivalence of DFA & NFA • Any NFA language can be described by some DFA • Adding non-determinism does not give any thing more • Why use NFAs then : • Easier to make for some languages • May have fewer states and less complex • Algorithm to convert NFA to DFA • For n state NFA,DFA may have up to 2n states • Can throw away inaccessible states • Observation : DFA has practically the same number of states as NFA though it often has more transitions

  10. NFA to DFA conversion • For an NFA, N = {Q, Σ, δ, q0, F}, • Construct the DFA, D = {Qd, Σ, δd, {q0}, Fd} • Qd = Powerset of Q • δd(S, a) = Up in S δ(p,a) for every S in Qd. • Fd = S : S is subset of Q and S has an accepting state of NFA • DFA operates on one state at a time, NFA operates on sets of states. • Given a state, NFA gives a set of new states • Make all possible sets of DFA states as NFA states • Transit from one set of states to a new set of all possible state set • Any set with an accepting state is the accepting state in NFA

  11. NFA to DFA conversion complexity • O(2n) (number of subsets of a set) • Efficient algorithm • Do not construct the entire power set • Start with start state • Only construct subsets that can reach an accepting state from the start state • The number of states in DFA is much less than 2n. • DFA has practically the same number of states as NFA though it often has more transitions

  12. εpsilon - NFA • Includes ε (the empty string, not in alphabet set) as a transition • ε is identity in concatenation • a.ε = ε.a = a for all a • Spontaneous transition without an input

  13. Equivalence to NFA • An ε-NFA language can be described by some NFA • Every NFA can be described by some DFA • Adding ε transition does not give any thing more • Why use ε-NFAs then : • Easier to make for some languages • Useful in proving equivalence of languages

  14. Conversion to NFA • Conversion aims to remove ε transitions • Define a new set of states • ε are contained inside the set • No ε arc leaves or enters the new set of states • Epsilon closure (eclose) • For a state, set of all states reachable spontaneously • Follow the ε arcs recursively and include reachable states in the epsilon closure

  15. epsilon-NFA to DFA conversion • For an ε-NFA, N = {Q, Σ, δ, q0, F}, • Construct the DFA, D = {Qd, Σ, δd, {eclose(q0)}, Fd} • Qd = { eclose(q) | q = eclose(q) and q in Q } • δd(S, a) = Up in S δ(p,eclose(a)) for every S in Qd. • Fd = S : S is subset of Q and S has an accepting state of NFA • DFA operates on one state at a time, ε-NFA operates on sets of states with no ε transition leaving the set • Make all eclose sets as DFA states • Transit from one set of states to a new set of all eclose state set • Any set with an accepting state is the accepting state in NFA

  16. Programs as Automatan • An imperative program can be represented as a Control Flow Graph (CFG) with • statements at nodes and • predicates at edges • It can be converted into a CFG with • both statements and predicates at edges • by pushing node statements up incoming edges • Such a CFG is a DFA • Program points are States • Statements are input symbols that change program state from program point to point

  17. Regular Expression • Algebraic expression to denote languages • Composed of symbols “ε”, “Ø”, “+”, “*”, “.”, “(“, “)” and alphabets • The language is generated using rules : • L(ε) = empty set • L(Ø) = empty set • L(a) = a for all alphabets a • L(p+q) = L(p) U L(q) • L(p.q) = { p’.q’ | p’ in L(p) & q’ in L(q) } • L(p*) = { qn | q in L(p) and n >= 0 }, q0= ε, qk=q.qk-1

  18. Regular Expression Example a+b.c The language generated is : { a, b.c } a.b.c*.d the language generated is : { a.b.d, a.b.c.d, a.b.c.c.d, a.b.c.c.c.d, … } A finite way to express an infinite language

  19. Equality of Languages DEFINITION • Two regular expression (or automaton) • are EQUAL • if they both generate same languages Thus (a.b)* + (b.a)* + a.(b.a)* + b.(b.a)* = (ε + b).(a.b)*.(ε+a)

  20. Algebraic laws of regular expressions • p + q = q + p • (p + q) + r = p + (q + r) • (p.q).r = p.(q.r) • Ø + p = p + Ø = p • ε.p = p.ε = p • Ø.p = p.Ø = Ø • p.(q=r) = p.q + p.r • (p + q).r = p.r + q.r • p + p = p • (p*)* = p* • Ø* = ε • ε* = ε • p.p* = p*.p • (p + q)* = (p*.q*)*

  21. Finite Automaton and Regular Expressions • Every language • defined by a finite automaton is also defined by some regular expression • defined by a regular expression is also defined by some DFA

  22. DFA to Regular expression • Hopcroft’s formula • Rij(k) = Rij(k-1)+Rik(k-1).(Rkk(k-1))*.Rkj(k-1) • Rij(n) is the regular expression of all paths from i to j. (n is the number of states) • States are sorted in some order and numbered 1 to n • Rij(k) is regular expression of all paths from i to j passing thru nodes whose sort order is less than k • Computed for all i,j for k=0, then k=1,…,k=n • Rs,f1(n)+…+Rs,fk(n) is the regular expression of the DFA • s is the start state, f1,…,fk are accepting states, n is the number of states.

  23. DFA to RE - complexity • Hopcroft formula is O(n34n), • n3 to compute the table and • 4n as size of regular expression grows by 4 every time. • In practice it is close to O(n3) • By simplifying the regular expression at every step and • using judicious algorithm avoiding recomputation of Rkk(k) • Most DFAs have almost n and not 2n accessible states • A faster state elimination method close to O(n2) is also available

  24. RE to Automatan conversion • Regular expression is converted to ε-NFA • ε-NFA can the be converted to NFA and to DFA • RE to ε-NFA conversion rules : • ε -> One edge (two state) DFA with ε transition • Ø -> Two state DFA with no edges • a -> Two state with “a” transition • + -> A new start/accept statejoining two arguments of + in parallel • . -> Accept of first is start of second • * -> An ε edge joining star/accept of argument and a new start/accept state • Convert resulting ε-NFA to a DFA

  25. Direct conversion • Augment regular expression r to (r).# • Position number for each occurrence of alphabet • Compute for each node of syntax tree • nullable (ε in the language) • firstpos (set of possible first alphabets) • lastpos (set of possible last alphabets) • Compute for each position • followpos (set of possible next alphabet after this position) • Construct the DFA

  26. Applications • Unix text search, search matching patterns (grep) • Lexical/Parser analysis • Parse text against a regular expression • find set of first tokens at this expression root • find set of last tkens at this expression root • can the expression at this root be null set • find set of next tokens after an alphabet position in a regular expression • Efficient search of patterns in very large repository (web text search)

  27. Regular Language DEFINITION • A language (a set of strings) • is defined to be a regular language if • it can be defined by a finite automaton • by a DFA or • by an NFA or • by an ε-NFA or • by a regular expression • Four different ways to describe a regular language

  28. Pumping Lemma • If L is a regular language then there exists • integer n such that • for every string w in L • we can break w into x, y, z such that w=x.y.z • y  ε • |x.y| =< n • x.yk.z is in L (for all k >= 0) • Proof based on • For a DFA of length n • any string of length > n • must revisit a state • Used to prove that a language is not regular

  29. Closure property • Language is a set of string over finite alphabets • Language operators : • Union of two languages L(A  B) = L(A)  L(B) - re • Intersection • Concatenation L(A.B) = { a.b | a in A, b in B} • Kleene Closure L(A*) = { an | a in A, n >= 0 } • a0 = ε for all a and an = an-1 • Compliment L(A’) = { a | a not in A } (with respect to some overall alphabet set) - dfa • Difference L(A-B) = L(A) – L(B) - dfa switch q0 F • Reversal L (A) = { ak.ak-1…a1 | a1…ak-1.ak in A } • Homomorphism – replace an alphabet with another regular expression • Inverse homomorphism

  30. Decision properties • Is the language described empty? • Is a particualr string in the described language? • Do two different of languages actually describe the same language?

  31. Conversions • Decision properties may require conversion between various forms. • Can the conversion be done in reasonable time?

  32. Equivalence of automata • Equivalence of two states • States p and q in an automaton are Defined to be equivalent if • For all input strings applied at state p or q • p ends up in an accepting state • if and only if • q also ends up in an accepting state • The accepting state reached by p does not have to be same accepting state as that reached by q

  33. Minimization of DFA • If two states p and q are equivalent • we can combine them together into a single state • it wont affect the language accepted by the DFA • This process of combining states together is called Minimization • Table-filling algorithm can find if two states are equivalent or not. Complexity O(n2) • Non-equivalent pairs are distinguishable

  34. MinimuMDFA • Minimum DFA is unique • Eliminate all states not reachable from start • Determine which states are equivalent • Partition states into blocks of equivalent states • Equivalence is transitive • Thus no state is in two blocks • Equivalence of two Regular Languages • Convert them into their minimum DFAs • and check for isomorphism • Union method • Make a minimum DFA of the union of the two • Start state of the two original DFAs must be equivalent if and only if DFAs are equivalent

More Related