1 / 99

Finite-State Machines with No Output Longin Jan Latecki Temple University

This presentation explores finite state machines with no output, focusing on Kleene closure, regular expressions, and implementing regular expressions using finite state automata.

kay-foreman
Download Presentation

Finite-State Machines with No Output Longin Jan Latecki Temple University

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. Based on Slides by Elsa L Gunter, NJIT, and by Costas Busch Finite-State Machines with No OutputLongin Jan Latecki Temple University

  2. Kleene closure • A and B are subsets of V*, where V is a vocabularyThe concatenation of A and B isAB={xy: x string in A and y string in B} • Example: A={0, 11} and B={1, 10, 110}AB={01,010,0110,111,1110,11110} • What is BA? • A0={λ}, where λ represents the empty stringAn+1=AnA for n=0,1,2,…

  3. Let A be any subset of V*. Kleene closure of A, denoted by A*, is Examples: If C={11}, then C*={12n: n=0,1,2,…} If B={0,1}, then B*=V*.

  4. Regular Expressions Regular expressions describe regular languages Example: describes the language

  5. Given regular expressions and Are regular expressions Recursive Definition Primitive regular expressions:

  6. Not a regular expression: Examples A regular expression:

  7. Languages of Regular Expressions : language of regular expression Example

  8. Definition For primitive regular expressions:

  9. Definition (continued) For regular expressions and

  10. Example Regular expression:

  11. Example Regular expression

  12. Example Regular expression

  13. = { all strings with at least two consecutive 0 } Example Regular expression

  14. = { all strings without two consecutive 0 } Example Regular expression

  15. Equivalent Regular Expressions • Definition: • Regular expressions and • are equivalent if

  16. and are equivalent regular expr. Example = { all strings without two consecutive 0 }

  17. Example: Lexing • Regular expressions good for describing lexemes (words) in a programming language • Identifier= (a  b  …  z  A  B  …  Z) (a  b  …  z  A  B  …  Z  0  1  …  9  _  ‘ )* • Digit = (0  1  …  9)

  18. Implementing Regular Expressions • Regular expressions, regular grammars reasonable way to generates strings in language • Not so good for recognizing when a string is in language • Regular expressions: which option to choose, how many repetitions to make • Answer: finite state automata

  19. Finite (State) Automata • A FA is similar to a compiler in that: • A compiler recognizes legal programs in some (source) language. • A finite-state machine recognizes legal strings in some language. • Example: Pascal Identifiers • sequences of one or more letters or digits, starting with a letter: letter | digit letter S A

  20. Finite Automaton Input String Output “Accept” or “Reject” Finite Automaton

  21. Finite State Automata • A finite state automation over an alphabet is illustrated by a state diagram: • a directed graph • edges are labeled with elements of alphabet, • some nodes (or states), marked as final • one node marked as start state

  22. Transition Graph initial state accepting state transition state

  23. Initial Configuration Input String

  24. Reading the Input

  25. Input finished accept

  26. Rejection

  27. Input finished reject

  28. Another Rejection

  29. reject

  30. Another Example

  31. Input finished accept

  32. Rejection Example

  33. Input finished reject

  34. Finite State Automata • A finite state automation M=(S,Σ,δ,s0,F) consists of • a finite set S of states, • a finite input alphabet Σ, • a state transition function δ: S x Σ S, • an initial state s0, • F subset of S that represent the final states.

  35. Finite Automata • Transition s1as2 • Is read ‘In state s1 on input “a” go to state s2’ • If end of input • If in accepting state => accept • Otherwise => reject • If no transition possible (got stuck) => reject • FSA = Finite State Automata

  36. Input Alphabet

  37. Set of States

  38. Initial State

More Related