Regular Languages Unit Tasks: Skills and Abilities - Prof. Eric Torng, Exams of Computer Science

The tasks and abilities required to master regular languages in computer science. Topics include computational models, distinguishability, algorithms, and proof techniques. Students will learn to 'compute' with automata, 'program' with fsa's and nfa's, 'debug' automata and expressions, and apply closure properties. They will also gain an understanding of deterministic and nondeterministic modes of computation.

Typology: Exams

Pre 2010

Uploaded on 07/22/2009

koofers-user-yse
koofers-user-yse 🇺🇸

10 documents

1 / 2

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Tasks List for Regular Languages Unit
Basic Tasks
Computational Models
Ability to “compute” with regular expressions, FSA's, NFA's
- this requires understanding configurations for automata
Ability to “program” with FSA's, NFA's, and regular expressions for simple languages L
- given a target language L, write an FSA or NFA M such that L(M) = L
- given a target language L, write a regular expression r such that L(r) = L
Ability to “debug” finite automata and regular expressions for simple languages L
- given an FSA or NFA M, give a natural English language description of L(M)
- given a regular expression r, give a natural English language description of L(r)
Distinguishability/Myhill-Nerode Theorem
Basic Distinguishability
- ability to identify two strings as distinguishable/indistinguishable
with respect to a given language L
- ability to prove two strings as distinguishable with respect to L
Myhill-Nerode Theorem
- extension of distinguishability idea into understanding how languages and
automata partition * into a finite number of equivalence classes
- ability to identify the equivalence classes formed by a given language
- ability to construct an FSA based on these classes
Algorithms we have encountered in this unit
Ability to execute these algorithms/constructions
- Set complement construction for FSA’s
- The 2FSAto1FSA construction
- Convert an NFA into an “equivalent” FSA
- Convert a reg. exp r into an “equivalent” NFA-/\
- ability to parse a regular expression by identifying “last” operator
- NFA-/\’s constructions for union, concatenation, and Kleene closure
Ability to abstractly execute these algorithms
- Given input automata with 7 states and 5 states, how many states will be in the resulting
automata?
Higher level understanding of principles behind these algorithms/constructions
- NFA to FSA conversion
- The idea that each state in the FSA corresponds to a set of states in the NFA
- reg exp to NFA- conversion
- idea of a recursive algorithm: recursive case and base cases
- understanding of why the various operators are handled the way they are
- LFSA closed under union, intersection, set difference, symmetric difference proofs
- the idea that we are running both input FSA's in parallel
- understanding how we handle what the new accepting states should be
- LFSA closed under set complement
- the idea of not modifying the input FSA except to switch yes and no answers
Ability to see how these algorithms put together lead to a powerful string searching algorithm
Ability to read and understand “parameterized” descriptions of languages
- understanding role of variables and parameters and their “binding” or “scope”
{an bn | n > 0}: numbers of a’s and b’s are equal because n is identical
{an | n > 0} concatenate {bn | n>0} produces {anbm | n,m > 0}, not {an bn | n > 0}
Synthesis Tasks
Ability to classify a given language as regular or not regular
Ability to identify true and false statements about the class of regular languages
pf2

Partial preview of the text

Download Regular Languages Unit Tasks: Skills and Abilities - Prof. Eric Torng and more Exams Computer Science in PDF only on Docsity!

Tasks List for Regular Languages Unit

Basic Tasks

Computational Models Ability to “compute” with regular expressions, FSA's, NFA's

  • this requires understanding configurations for automata Ability to “program” with FSA's, NFA's, and regular expressions for simple languages L
  • given a target language L, write an FSA or NFA M such that L(M) = L
  • given a target language L, write a regular expression r such that L(r) = L Ability to “debug” finite automata and regular expressions for simple languages L
  • given an FSA or NFA M, give a natural English language description of L(M)
  • given a regular expression r, give a natural English language description of L(r) Distinguishability/Myhill-Nerode Theorem Basic Distinguishability
  • ability to identify two strings as distinguishable/indistinguishable with respect to a given language L
  • ability to prove two strings as distinguishable with respect to L Myhill-Nerode Theorem
  • extension of distinguishability idea into understanding how languages and automata partition * into a finite number of equivalence classes
  • ability to identify the equivalence classes formed by a given language
  • ability to construct an FSA based on these classes Algorithms we have encountered in this unit Ability to execute these algorithms/constructions
  • Set complement construction for FSA’s
  • The 2FSAto1FSA construction
  • Convert an NFA into an “equivalent” FSA
  • Convert a reg. exp r into an “equivalent” NFA-/\
  • ability to parse a regular expression by identifying “last” operator
  • NFA-/\’s constructions for union, concatenation, and Kleene closure Ability to abstractly execute these algorithms
  • Given input automata with 7 states and 5 states, how many states will be in the resulting automata? Higher level understanding of principles behind these algorithms/constructions
  • NFA to FSA conversion
  • The idea that each state in the FSA corresponds to a set of states in the NFA
  • reg exp to NFA- conversion
  • idea of a recursive algorithm: recursive case and base cases
  • understanding of why the various operators are handled the way they are
  • LFSA closed under union, intersection, set difference, symmetric difference proofs
  • the idea that we are running both input FSA's in parallel
  • understanding how we handle what the new accepting states should be
  • LFSA closed under set complement
  • the idea of not modifying the input FSA except to switch yes and no answers Ability to see how these algorithms put together lead to a powerful string searching algorithm Ability to read and understand “parameterized” descriptions of languages
  • understanding role of variables and parameters and their “binding” or “scope” {an^ bn^ | n > 0}: numbers of a’s and b’s are equal because n is identical {an^ | n > 0} concatenate {bn^ | n>0} produces {anbm^ | n,m > 0}, not {an^ bn^ | n > 0} Synthesis Tasks Ability to classify a given language as regular or not regular Ability to identify true and false statements about the class of regular languages

Proof Techniques Writing proofs

  • ability to recognize when proof by counterexample is sufficient
  • ability to write high level proof outlines for closure property proofs
  • ability to write high level proof outlines for proofs about the relative power of two computational models Ability to compare different types of proofs seen in class
  • relative power proofs versus closure property proofs Closure properties
  • ability to apply closure properties to conclude a language is/is not regular Deterministic/Nondeterministic Modes of computation Understanding of nondeterminism and determinism in computational models
  • deterministic computational model: next action is always well defined
  • computation produces a path because there is always only one next action
  • nondeterministic computational model: next action is not always uniquely defined,
  • computation produces a graph because there can be more than one next action
  • ability to recognize nondeterminism
  • any real/implemented model is deterministic

Advanced Tasks

Constructions/Algorithms

  • ability to perform a new construction described mathematically
  • Ability to argue why certain constructions cannot be used to prove certain closure properties - for example, why does the set complement construction that works for FSA’s NOT work for NFA's? Proof Techniques
  • ability to apply construction used in one setting to a new setting
  • e.g. applying idea used in solvable languages setting to reg. lang. setting
  • ability to perform a new generic element proof not seen before
  • ability to prove/disprove new closure property type statements
  • counterexamples
  • set property (or closure property) proofs
  • constructive proofs
  • Ability to see/describe similarities/differences between different proof techniques Myhill-Nerode Theorem
  • An ability to use M-N Theorem to prove that a nonregular language is not regular Decision problems about regular languages
  • Understanding what these problems are
  • Inputs to problems are typically programs (e.g. FSA's, NFA's)
  • Understanding how we solve the basic decision problems dealing with
  • emptiness, finiteness, and infiniteness of language
  • Understanding how we can use previous constructions with these basic solutions to solve just about any decision problem concerning regular languages
  • connection to input transformations from previous unit

Extra Credit

Minimizing FSA: ability to take an FSA and construct an equivalent minimum state FSA NFA-/\ to NFA: ability to take an NFA-/\ and construct an equivalent NFA